Copy of aRts for Trinity modifications

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/dependencies/arts@1070145 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

160 files changed, 68997 insertions, 0 deletions

diff --git a/flow/Makefile.am b/flow/Makefile.am
new file mode 100644
index 0000000..720ca47
--- /dev/null
+++ b/flow/Makefile.am
@@ -0,0 +1,49 @@
+
+SUBDIRS = mcopclass gsl gslpp
+INCLUDES = -I$(top_srcdir)/mcop -I$(top_builddir)/mcop $(all_includes)
+AM_CXXFLAGS = $(MAS_CFLAGS) $(JACK_CFLAGS) -DQT_CLEAN_NAMESPACE
+
+####### Files
+
+lib_LTLIBRARIES = libartsflow_idl.la libartsflow.la
+
+libartsflow_idl_la_SOURCES = artsflow.cc
+libartsflow_idl_la_LDFLAGS = -no-undefined -version-info 1:0 $(all_libraries)
+libartsflow_idl_la_LIBADD = $(top_builddir)/mcop/libmcop.la $(LIBPOSIX4)
+
+libartsflow_la_LIBADD = $(top_builddir)/mcop/libmcop.la libartsflow_idl.la $(top_builddir)/flow/gslpp/libgslpp.la $(LIBAUDIOFILE) $(LIBASOUND) $(LIBAUDIOIO) $(LIBOSSAUDIO) $(LIBAUDIONAS) $(LIBCSL) $(SGILIBAUDIO) $(LIBESD) $(LIBMAS) $(JACK_LIBADD) -lm \
+  $(top_builddir)/flow/gsl/libgsl.la
+libartsflow_la_LDFLAGS = $(MAS_LDFLAGS) $(JACK_LDFLAGS) $(LIBAUDIOFILE_LDFLAGS) $(LIBAUDIONAS_LDFLAGS) $(LIBESD_LDFLAGS) -no-undefined -version-info 1:0
+libartsflow_la_COMPILE_FIRST = artsflow.h
+libartsflow_la_SOURCES =  synth_play_impl.cc \
+  gslschedule.cc audiosubsys.cc \
+  pipebuffer.cc convert.cc synth_wave_sin_impl.cc synth_frequency_impl.cc \
+  synth_multi_add_impl.cc synth_add_impl.cc synth_mul_impl.cc \
+  synth_play_wav_impl.cc stdsynthmodule.cc cache.cc asyncschedule.cc \
+  bytestreamtoaudio_impl.cc stereovolumecontrol_impl.cc \
+  stereoeffectstack_impl.cc fft.c stereofftscope_impl.cc virtualports.cc \
+  bus.cc audiomanager_impl.cc synth_record_impl.cc resample.cc \
+  audioio.cc audioiooss.cc audioioalsa.cc audioioalsa9.cc \
+  audioionull.cc audioiolibaudioio.cc audioioesd.cc audioiojack.cc \
+  audioiosun.cc audioioaix.cc audioionas.cc cpuinfo.cc \
+  audioioossthreaded.cc audiotobytestream_impl.cc audioiosgi.cc \
+  audioiocsl.cc audioiomas.cc datahandle_impl.cc
+
+artsincludedir = $(includedir)/arts
+artsinclude_HEADERS = artsflow.h audiosubsys.h cache.h \
+  cachedwav.h convert.h pipebuffer.h stdsynthmodule.h \
+  synthschedule.h fft.h artsflow.idl audioio.h resample.h \
+  cpuinfo.h bufferqueue.h gslschedule.h
+
+DISTCLEANFILES = artsflow.cc artsflow.h artsflow.mcoptype artsflow.mcopclass
+
+artsflow.cc artsflow.h: $(top_srcdir)/flow/artsflow.idl $(MCOPIDL)
+	$(MCOPIDL) -t $(top_srcdir)/flow/artsflow.idl
+
+artsflow.mcoptype: artsflow.h
+artsflow.mcopclass: artsflow.h
+
+######## install idl typeinfo files
+
+mcoptypedir = $(libdir)/mcop
+mcoptype_DATA = artsflow.mcoptype artsflow.mcopclass
diff --git a/flow/artsflow.idl b/flow/artsflow.idl
new file mode 100644
index 0000000..44424e0
--- /dev/null
+++ b/flow/artsflow.idl
@@ -0,0 +1,566 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+/*
+ * arts.idl - MCOP port. What's missing currently in MCOP?
+ *
+ * -   namespaces (module)
+ */
+
+module Arts {  // analog real time synthesizer
+
+enum AutoSuspendState { asNoSuspend, asSuspend, asSuspendStop, asSuspendMask = 0x3,
+                        asProducer = 0x10, asConsumer = 0x20, asDirectionMask = 0x30 };
+
+/**
+ * The SynthModule interface is the base for all modules containing streams.
+ *
+ * There are two goals achieved by this interface. On one side, there is
+ * functionality which users of stream carrying modules want to use (which
+ * is: start streaming, stop streaming).
+ *
+ * On the other hand, there is functionality which the flow system will use
+ * to achieve these goals.
+ */
+interface SynthModule {
+	// interface for users of this module
+
+	/**
+	 * This function starts the streaming (e.g. the module will start
+	 * producing samples) - if you write a module, do not reimplement this,
+	 * instead reimplement streamInit/streamStart
+	 */
+	void start();
+
+	/**
+	 * This function stops the streaming - if you write a plugin, do not
+	 * reimplement this, instead reimplement streamEnd
+	 */
+	void stop();
+
+	// interface for people implementing modules
+
+	/**
+	 * this is supposed to be the initialization every module passes after
+	 * all attributes have been set up (e.g. you can see which file to open,
+	 * how to initialize your filter coefficients or whatever)
+	 */
+	void streamInit();
+
+	/**
+	 * starts the I/O of the module
+	 */
+	void streamStart();
+
+	/**
+	 * stop the thing again, and free data possibly allocated in streamInit
+	 */
+	void streamEnd();
+
+	/**
+	 * If you run a mixer desk (without anything connected), no calculations
+	 * need to be done - since the output is silent anyway. For this reason,
+	 * there exists this autosuspend attribute. It allows the flow system
+	 * to detect the idle condition, and start suspending the calculations,
+	 * until something "important" happens again.
+	 *
+	 * There are three possible values:
+	 *
+	 * @li  asNoSuspend - this one is appropriate when you have a module that
+	 *                    is active by itself
+	 * @li  asSuspend   - this one is appropriate for modules that "do nothing"
+	 *                    by themselves
+	 * @li  asSuspendStop - this one is for modules that should be stopped, when
+	 *                    the system gets suspended, and restarted when the
+	 *                    system will start again - an example for this is
+	 *                    soundcard output
+	 *
+	 * A module should choose asSuspend (or asSuspendStop) only if the
+	 * following conditions are true:
+	 *
+	 * @li given constant inputs (like 3.0 on all ports), the module will
+	 *     give constant output after some time
+	 * @li given only 0.0 inputs, the module will give only 0.0 outputs
+	 *     after some time
+	 * @li the module does not synchronize itself through signal flow (i.e.
+	 *     a midi sequence which "knows" when a second has passed through
+	 *     the signal flow breaks when suspension happens)
+	 * @li the module can't be brought to do something with a method
+	 *     invocation (i.e. a module which starts generating noise for
+	 *     a second whenever the noise() method is called is not suspendable)
+	 * @li the module has no internal state that changes over time when only
+	 *     constant inputs are given
+	 *
+	 * Typical examples for suspendable modules are arithmetic operations,
+	 * filters, delay/hall/reverb.
+	 *
+	 * Typical examples for non-suspendable modules are sequences, midi stuff,
+	 * oscillators, sample players,...
+	 *
+	 * To deal with modules which either input data from some external source
+	 * (i.e. soundcard input) or output data to some external destination,
+	 * (i.e. soundcard output) the following flags are available:
+	 *
+	 * @li	asProducer  - set this flag for modules which fulfill the conditions
+	 *                    for a suspendable module, but produce non-zero output
+	 *                    even when left alone
+	 * @li	asConsumer  - set this flag for modules which write the data to
+	 *                    some external destination - that is - definitely
+	 *                    require constant input to be suspended
+	 *
+	 * The suspension algorithm will first divide the graph of modules into
+	 * subgraphs of interconnected modules. A subgraph is suspendable if
+	 * all of its modules are suspendable and the subgraph does not contain
+	 * producer(s) and consumer(s) at the same time.
+	 *
+	 * Finally, our module graph is suspendable if all its subgraphs are.
+	 */
+	readonly attribute AutoSuspendState autoSuspend;
+};
+
+/**
+ * Plays a stream of audio data to the soundcard
+ */
+interface Synth_PLAY : SynthModule {
+	// attribute string channels;
+	default in audio stream invalue_left,invalue_right;
+};
+
+/**
+ * Records a stream of audio data from the soundcard
+ */
+interface Synth_RECORD : SynthModule {
+	// attribute string channels;
+	default out audio stream left,right;
+};
+
+/**
+ * A frequency generator
+ *
+ * This kind of object is used to create frequencies. Oscillators are connected
+ * at the output of this object
+ */
+interface Synth_FREQUENCY : SynthModule {
+	in audio stream frequency;
+	out audio stream pos;
+};
+
+/**
+ * A sine wave
+ */
+interface Synth_WAVE_SIN : SynthModule {
+	in audio stream pos;
+	out audio stream outvalue;
+};
+
+/**
+ * A module which mixes an arbitary number of audio streams
+ */
+interface Synth_MULTI_ADD : SynthModule {
+	in multi audio stream invalue;
+	out audio stream outvalue;
+};
+
+/**
+ * A module which adds two audio streams
+ */
+interface Synth_ADD : SynthModule {
+	default in audio stream invalue1,invalue2;
+	out audio stream outvalue;
+};
+
+/**
+ * Multiplies two audio streams
+ */
+interface Synth_MUL : SynthModule {
+	in audio stream invalue1,invalue2;
+	out audio stream outvalue;
+	default invalue1, invalue2;
+};
+
+/**
+ * This plays a wave file
+ */
+interface Synth_PLAY_WAV : SynthModule {
+	/**
+	 * How fast should it be played? 1.0 = normal speed
+	 */
+	attribute float speed;
+	/**
+	 * Which file should be played
+	 */
+	attribute string filename;
+	/**
+	 * Is true as soon as the file is finished
+	 */
+	readonly attribute boolean finished;
+
+	out audio stream left, right;
+	default left, right;
+};
+
+/**
+ * sends data to a bus - busses are dynamic N:M connections - all signals
+ * from all uplinks are mixed together, and sent to all downlinks
+ */
+interface Synth_BUS_UPLINK : SynthModule {
+	/**
+	 * the name of the bus to use
+	 */
+	attribute string busname;
+
+	default in audio stream left,right;
+};
+
+/**
+ * receives data from a bus - busses are dynamic N:M connections - all signals
+ * from all uplinks are mixed together, and sent to all downlinks
+ */
+interface Synth_BUS_DOWNLINK : SynthModule {
+	/**
+	 * the name of the bus to use
+	 */
+	attribute string busname;
+
+	default out audio stream left,right;
+};
+
+
+/**
+ * Byte stream to audio conversion object
+ *
+ * Converts an asynchronous byte stream to a synchronous audio stream
+ */
+interface ByteStreamToAudio : SynthModule {
+	attribute long samplingRate;
+	attribute long channels;
+	attribute long bits;
+
+	/**
+	 * is conversion currently running, or is it stalled due to the fact
+	 * that there is not enough input input?
+	 */
+	readonly attribute boolean running;
+
+	async in byte stream indata;
+
+	out audio stream left,right;
+	default left;
+	default right;
+};
+
+/**
+ * Audio to Byte stream conversion object
+ *
+ * Converts a synchronous audio stream to an asynchronous byte stream
+ */
+interface AudioToByteStream : SynthModule {
+	attribute long samplingRate;
+	attribute long channels;
+	attribute long bits;
+
+	async out byte stream outdata;
+
+	in audio stream left,right;
+	default left;
+	default right;
+};
+
+/**
+ * Base interface for all stereo effects
+ */
+interface StereoEffect : SynthModule {
+	default in audio stream inleft, inright;
+	default out audio stream outleft, outright;
+};
+
+/**
+ * this is a simple clipping stereo volume control
+ */
+interface StereoVolumeControl : StereoEffect {
+	attribute float scaleFactor;
+	readonly attribute float currentVolumeLeft;
+	readonly attribute float currentVolumeRight;
+};
+
+/**
+ * A funny FFT scope
+ */
+interface StereoFFTScope : StereoEffect {
+	readonly attribute sequence<float> scope;
+};
+
+/**
+ * A stack of stereo effects
+ */
+interface StereoEffectStack : StereoEffect {
+	/**
+	 * inserts an effect at the top side (= directly after the input)
+	 *
+	 * @returns an ID which can be used to remove the effect again
+	 */
+	long insertTop(StereoEffect effect, string name);
+
+	/**
+	 * inserts an effect at the bottom (= close to the output) side
+	 *
+	 * @returns an ID which can be used to remove the effect again
+	 */
+	long insertBottom(StereoEffect effect, string name);
+
+	/**
+	 * removes an effect again
+	 */
+	void remove(long ID);
+};
+
+/*
+ * Audio Manager stuff
+ */
+
+enum AudioManagerDirection { amPlay, amRecord };
+
+/**
+ * Information structure for audio manager clients
+ */
+struct AudioManagerInfo {
+	long ID;
+	string destination;
+
+	AudioManagerDirection direction;
+	string title, autoRestoreID;
+};
+
+/**
+ * an audio manager client
+ */
+interface AudioManagerClient {
+	readonly attribute long ID;
+	attribute AudioManagerDirection direction;
+	attribute string title, autoRestoreID;
+
+	void constructor(AudioManagerDirection direction, string title,
+					 string autoRestoreID);
+};
+
+/**
+ * The audio manager interface
+ */
+interface AudioManager {
+	/**
+	 * a list of destinations, where you can play/record data to/from
+	 */
+	readonly attribute sequence<string> destinations;
+
+	/**
+	 * a list of clients
+	 */
+	readonly attribute sequence<AudioManagerInfo> clients;
+
+	/**
+	 * this is incremented each time a change is made (i.e. new client attached)
+	 * TODO: SHOULD GO AWAY WITH ATTRIBUTE WATCHING
+	 */
+	readonly attribute long changes;
+
+	/**
+	 * this is used to route a client to another destination
+	 */
+	void setDestination(long ID, string destination);
+};
+/**
+ * This is a virtual output port, which you use to play data. Where exactly
+ * this data gets played is managed by the audiomanager.
+ *
+ * Creation: there are two ways to initialize a Synth_AMAN_PLAY - one is
+ * to set title and autoRestoreID to sensible (non empty) values. The other
+ * is to pass an already initialized AudioManagerClient on the constructor.
+ */
+interface Synth_AMAN_PLAY : SynthModule {
+	attribute string title, autoRestoreID;
+	void constructor(AudioManagerClient client);
+
+	default in audio stream left, right;
+};
+
+/**
+ * This is a virtual input port, which you use to record data. Where this
+ * data comes from is in turn managed by the audiomanager.
+ *
+ * Creation: there are two ways to initialize a Synth_AMAN_RECORD - one is
+ * to set title and autoRestoreID to sensible (non empty) values. The other
+ * is to pass an already initialized AudioManagerClient on the constructor.
+ */
+interface Synth_AMAN_RECORD : SynthModule {
+	attribute string title, autoRestoreID;
+	void constructor(AudioManagerClient client);
+
+	default out audio stream left, right;
+};
+
+/* --------------------------------------------------------------------- */
+
+/**
+ * Wraps a datahandle. That is an abstraction for a float value array
+ * which can be directly loaded data from a file or have some
+ * processing stages in between (caching, reversing, cropping...)
+ * which are hidden to this interface.
+ * In contrast to the underlying C++ API, this datahandle is already
+ * open()ed after creation, so you can access its information (like
+ * channelCount) without further action.
+ * A datahandle normally has one more important function: read() which
+ * is not wrapped in MCOP because of the overhead of the data
+ * transfer. (If there is need for sth. like that in the future,
+ * one could maybe find a solution.)
+ */
+interface DataHandle {
+	readonly attribute long bitDepth;
+	readonly attribute long channelCount;
+	readonly attribute long valueCount;
+	/**
+	 * error code open() returned
+	 */
+	readonly attribute long errorNo;
+};
+
+/**
+ * Represents a datahandle which delivers the data from the underlying
+ * sourceDatahandle in reverse order.
+ */
+interface ReversedDataHandle : DataHandle {
+	void init(DataHandle sourceHandle);
+};
+
+/**
+ * Represents a datahandle which delivers an "inner" part of the data
+ * from the underlying sourceDatahandle. You can cut away parts at the
+ * start and/or the end with this.
+ */
+interface CroppedDataHandle : DataHandle {
+	void init(DataHandle sourceHandle,
+			  long headCutValueCount,
+			  long tailCutValueCount);
+};
+
+/**
+ * Represents a datahandle which delivers the data from the underlying
+ * sourceDatahandle without the "inner" part containing the values
+ * [cutOffset..cutOffset+cutValueCount-1], which will be cut away.
+ */
+interface CutDataHandle : DataHandle {
+	void init(DataHandle sourceHandle,
+			  long cutOffset,
+			  long cutValueCount);
+};
+
+/**
+ * DataHandlePlay uses a gsl_wave_osc to play back data from a
+ * DataHandle using sophisticated anti-aliasing filtering and caching
+ * techniques. (Though not implemented at the time of writing this, it
+ * will be optimized for cases where the anti-aliasing is not needed
+ * because the mixerFrequency equals the current soundserver's.)
+ */
+interface DataHandlePlay : SynthModule {
+	/**
+	 * Which data should be played?
+	 */
+	attribute DataHandle handle;
+	/**
+	 * What is the normal mixer frequency the data from the handle
+	 * should be played back at? (default: current mixing frequency
+	 * of the soundserver, e.g. 44100)
+	 */
+	attribute float mixerFrequency;
+	/**
+	 * Which channel of the datahandle should by played?
+	 * (defaults to 0 = the first channel)
+	 */
+	attribute long channelIndex;
+	/**
+	 * How fast should the data be played?
+	 * (defaults to 1.0 = normal speed, see mixerFrequency)
+	 */
+	attribute float speed;
+	/**
+	 * Current position while playing, in fact it's the index in the
+	 * datahandle, so 0 <= pos < handle.valueCount
+	 */
+	attribute long pos;
+	/**
+	 * Is true as soon as the file is finished
+	 */
+	readonly attribute boolean finished;
+	/**
+	 * Can be used to pause and/or continue playing
+	 */
+	attribute boolean paused;
+
+	default out audio stream outvalue;
+
+	DataHandlePlay clone();
+};
+
+/**
+ * DataHandle which represents sample data loaded from a file. Note
+ * that the samples from all channels are interleaved, that is, the
+ * samples of the first channel in a stereo file are found at offsets
+ * 0,2,4,6,.. etc.
+ */
+interface WaveDataHandle : DataHandle {
+	/**
+	 * Properties of the loaded sample data. Note that those
+	 * properties are only available from a WaveDataHandle, but may be
+	 * available from a DataHandle in the future.
+	 */
+	readonly attribute float mixerFrequency;
+	readonly attribute float oscillatorFrequency;
+
+	/**
+	 * Load the first wavechunk from a file and return true on
+	 * success. A more specific error code is not available at the
+	 * moment.
+	 */
+	boolean load(string filename);
+
+	/**
+	 * Load a specific wavechunk from a file and return true on
+	 * success. A more specific error code is not available at the
+	 * moment.
+	 */
+	boolean load(string filename,
+				 long waveIndex, long chunkIndex);
+
+	/**
+	 * Return true if and only if a wavechunk was successfully loaded
+	 * from a file.
+	 */
+	readonly attribute boolean isLoaded;
+
+	/**
+	 * Creates a DataHandlePlay object with the important attributes
+	 * handle, mixerFrequency and channelCount already set to play
+	 * this WaveDataHandle.
+	 */
+	DataHandlePlay createPlayer();
+};
+
+};
diff --git a/flow/asyncschedule.cc b/flow/asyncschedule.cc
new file mode 100644
index 0000000..b3251a7
--- /dev/null
+++ b/flow/asyncschedule.cc
@@ -0,0 +1,553 @@
+    /*
+
+    Copyright (C) 2000,2001 Stefan Westerfeld
+                            stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include <iostream>
+#include "asyncschedule.h"
+
+using namespace std;
+using namespace Arts;
+
+#include "debug.h"
+#include <stdio.h>
+
+/* Since this file is a tad bit more complex, here is some basic documentation:
+
+1) ASyncPort: There are asynchronous ports which are parts of the standard-
+   flowsystem schedule nodes. Their lifetime starts whenever an asynchronous
+   stream gets created by the flow system, and ends when the schedule node
+   gets destroyed. Basically, an ASyncPort has two functions:
+
+   * it is a "Port", which means that it gets connect(), disconnect() and
+     other calls from the flowsystem
+
+   * it is a "GenericDataChannel", which means that DataPackets can interact
+     with it
+
+   Although there will be ASyncPorts which only send data and ASyncPorts which
+   only receive data (there are none that do both), there are no distinct
+   classes for this.
+
+2) Standard case: a DataPacket that gets transported over a datachannel locally:
+
+   1. the user allocates himself a datapacket "packet"
+   2. the user calls "packet->send()", which in turn calls
+      ASyncPort::sendPacket(packet)
+   3. the ASyncPort sends the DataPacket to every subscriber (incrementing the
+      useCount) over the NotificationManager
+   4. the NotificationManager delivers the DataPackets to the receiver
+   5. eventually, the receiver confirms using "packet->processed()"
+   6. the packet informs the ASyncPort::processedPacket()
+   7. the packet is freed
+
+variant (pulling):
+
+   1. the user gets told by the ASyncPort: produce some data, here is a "packet"
+   2. the user calls "packet->send()", which in turn calls
+      ASyncPort::sendPacket(packet)
+   3. the ASyncPort sends the DataPacket to every subscriber (incrementing the
+      useCount) over the NotificationManager
+   4. the NotificationManager delivers the DataPackets to the receiver
+   5. eventually, the receiver confirms using "packet->processed()"
+   6. the packet informs the ASyncPort::processedPacket()
+   7. the ASyncPort restarts with 1.
+
+3) Remote case: the remote case follows from the local case by adding two extra
+things: one object that converts packets from their packet form to a message
+(ASyncNetSend), and one object that converts packets from the message form
+to a packet again. Effectively, the sending of a single packet looks like
+this, then:
+
+   1-S. the user allocates himself a datapacket "packet"
+   2-S. the user calls "packet->send()", which in turn calls
+        ASyncPort::sendPacket(packet)
+   3-S. the ASyncPort sends the DataPacket to every subscriber (incrementing the
+        useCount) over the NotificationManager
+   4-S. the NotificationManager delivers the DataPackets to the ASyncNetSend
+   5-S. the ASyncNetSend::notify method gets called, which in turn converts
+        the packet to a network message
+    
+	... network transfer ...
+   
+   6-R. the ASyncNetReceive::receive method gets called - the method creates
+        a new data packet, and sends it using the NotificationManager again
+   7-R. the NotificationManager delivers the DataPacket to the receiver
+   8-R. eventually, the receiver confirms using "packet->processed()"
+   9-R. the packet informs the ASyncNetReceive::processedPacket() which
+        frees the packet and tells the (remote) sender that it went all right
+
+	... network transfer ...
+ 
+   10-S. eventually, ASyncNetSend::processed() gets called, and confirms
+         the packet using "packet->processed()"
+   11-S. the packet informs the ASyncPort::processedPacket()
+   12-S. the packet is freed
+
+variant(pulling):
+
+   works the same as in the local case by exchanging steps 1-S and 12-S
+
+4) ownership:
+
+   * ASyncPort: is owned by the Object which it is a part of, if the object
+   dies, ASyncPort dies unconditionally
+
+   * DataPacket: is owned by the GenericDataChannel they are propagated over,
+   that is, the ASyncPort normally - however if the DataPacket is still in
+   use (i.e. in state 5 of the local case), it will take responsibility to
+   free itself once all processed() calls have been collected
+
+   * ASyncNetSend, ASyncNetReceive: own each other, so that if the sender dies,
+   the connection will die as well, and if the receiver dies, the same happens
+
+*/
+
+#undef DEBUG_ASYNC_TRANSFER
+
+ASyncPort::ASyncPort(const std::string& name, void *ptr, long flags,
+		StdScheduleNode* parent) : Port(name, ptr, flags, parent), pull(false)
+{
+	stream = (GenericAsyncStream *)ptr;
+	stream->channel = this;
+	stream->_notifyID = notifyID = parent->object()->_mkNotifyID();
+}
+
+ASyncPort::~ASyncPort()
+{
+	/* 
+	 * tell all outstanding packets that we don't exist any longer, so that
+	 * if they feel like they need to confirm they have been processed now,
+	 * they don't talk to an no longer existing object about it
+	 */
+	while(!sent.empty())
+	{
+		sent.front()->channel = 0;
+		sent.pop_front();
+	}
+
+	/* disconnect remote connections (if present): the following things will
+	 * need to be ensured here, since we are being deleted:
+     *
+	 *  - the senders should not talk to us after our destructor
+	 *  - all of our connections need to be disconnected
+	 *  - every connection needs to be closed exactly once
+     *
+	 * (closing a connection can cause reentrancy due to mcop communication)
+	 */
+	while(!netSenders.empty())
+		netSenders.front()->disconnect();
+
+	FlowSystemReceiver receiver = netReceiver;
+	if(!receiver.isNull())
+		receiver.disconnect();
+}
+
+//-------------------- GenericDataChannel interface -------------------------
+
+void ASyncPort::setPull(int packets, int capacity)
+{
+	pullNotification.receiver = parent->object();
+	pullNotification.ID = notifyID;
+	pullNotification.internal = 0;
+	pull = true;
+
+	for(int i=0;i<packets;i++)
+	{
+		GenericDataPacket *packet = stream->createPacket(capacity);
+		packet->useCount = 0;
+		pullNotification.data = packet;
+		NotificationManager::the()->send(pullNotification);
+	}
+}
+
+void ASyncPort::endPull()
+{
+	pull = false;
+	// TODO: maybe remove all pending pull packets here
+}
+
+void ASyncPort::processedPacket(GenericDataPacket *packet)
+{
+	int count = 0;
+	list<GenericDataPacket *>::iterator i = sent.begin();
+	while(i != sent.end())
+	{
+		if(*i == packet)
+		{
+			count++;
+			i = sent.erase(i);
+		}
+		else i++;
+	}
+	assert(count == 1);
+
+#ifdef DEBUG_ASYNC_TRANSFER
+	cout << "port::processedPacket" << endl;
+#endif
+	assert(packet->useCount == 0);
+	if(pull)
+	{
+		pullNotification.data = packet;
+		NotificationManager::the()->send(pullNotification);
+	}
+	else
+	{
+		stream->freePacket(packet);
+	}
+}
+
+void ASyncPort::sendPacket(GenericDataPacket *packet)
+{
+	bool sendOk = false;
+
+#ifdef DEBUG_ASYNC_TRANSFER
+	cout << "port::sendPacket" << endl;
+#endif
+
+	if(packet->size > 0)
+	{
+		vector<Notification>::iterator i;
+		for(i=subscribers.begin(); i != subscribers.end(); i++)
+		{
+			Notification n = *i;
+			n.data = packet;
+			packet->useCount++;
+#ifdef DEBUG_ASYNC_TRANSFER
+			cout << "sending notification " << n.ID << endl;
+#endif
+			NotificationManager::the()->send(n);
+			sendOk = true;
+		}
+	}
+
+	if(sendOk)
+		sent.push_back(packet);
+	else
+		stream->freePacket(packet);
+}
+
+//----------------------- Port interface ------------------------------------
+
+void ASyncPort::connect(Port *xsource)
+{
+	arts_debug("port(%s)::connect",_name.c_str());
+
+	ASyncPort *source = xsource->asyncPort();
+	assert(source);
+	addAutoDisconnect(xsource);
+
+	Notification n;
+	n.receiver = parent->object();
+	n.ID = notifyID;
+	n.internal = 0;
+	source->subscribers.push_back(n);
+}
+
+void ASyncPort::disconnect(Port *xsource)
+{
+	arts_debug("port::disconnect");
+
+	ASyncPort *source = xsource->asyncPort();
+	assert(source);
+	removeAutoDisconnect(xsource);
+
+	// remove our subscription from the source object
+	vector<Notification>::iterator si;
+	for(si = source->subscribers.begin(); si != source->subscribers.end(); si++)
+	{
+		if(si->receiver == parent->object())
+		{
+			source->subscribers.erase(si);
+			return;
+		}
+	}
+
+	// there should have been exactly one, so this shouldn't be reached
+	assert(false);
+}
+
+ASyncPort *ASyncPort::asyncPort()
+{
+	return this;
+}
+
+GenericAsyncStream *ASyncPort::receiveNetCreateStream()
+{
+	return stream->createNewStream();
+}
+
+NotificationClient *ASyncPort::receiveNetObject()
+{
+	return parent->object();
+}
+
+long ASyncPort::receiveNetNotifyID()
+{
+	return notifyID;
+}
+
+// Network transparency
+void ASyncPort::addSendNet(ASyncNetSend *netsend)
+{
+	Notification n;
+	n.receiver = netsend;
+	n.ID = netsend->notifyID();
+	n.internal = 0;
+	subscribers.push_back(n);
+	netSenders.push_back(netsend);
+}
+
+void ASyncPort::removeSendNet(ASyncNetSend *netsend)
+{
+	arts_return_if_fail(netsend != 0);
+	netSenders.remove(netsend);
+
+	vector<Notification>::iterator si;
+	for(si = subscribers.begin(); si != subscribers.end(); si++)
+	{
+		if(si->receiver == netsend)
+		{
+			subscribers.erase(si);
+			return;
+		}
+	}
+	arts_warning("Failed to remove ASyncNetSend (%p) from ASyncPort", netsend);
+}
+
+void ASyncPort::setNetReceiver(ASyncNetReceive *receiver)
+{
+	arts_return_if_fail(receiver != 0);
+
+	FlowSystemReceiver r = FlowSystemReceiver::_from_base(receiver->_copy());
+	netReceiver = r;
+}
+
+void ASyncPort::disconnectRemote(const string& dest)
+{
+	list<ASyncNetSend *>::iterator i;
+
+	for(i = netSenders.begin(); i != netSenders.end(); i++)
+	{
+		if((*i)->dest() == dest)
+		{
+			(*i)->disconnect();
+			return;
+		}
+	}
+	arts_warning("failed to disconnect %s in ASyncPort", dest.c_str());
+}
+
+ASyncNetSend::ASyncNetSend(ASyncPort *ap, const std::string& dest) : ap(ap)
+{
+	_dest = dest;
+	ap->addSendNet(this);
+}
+
+ASyncNetSend::~ASyncNetSend()
+{
+	while(!pqueue.empty())
+	{
+		pqueue.front()->processed();
+		pqueue.pop();
+	}
+	if(ap)
+	{
+		ap->removeSendNet(this);
+		ap = 0;
+	}
+}
+
+long ASyncNetSend::notifyID()
+{
+	return 1;
+}
+
+void ASyncNetSend::notify(const Notification& notification)
+{
+	// got a packet?
+	assert(notification.ID == notifyID());
+	GenericDataPacket *dp = (GenericDataPacket *)notification.data;
+	pqueue.push(dp);
+
+	/*
+	 * since packets are delivered asynchronously, and since disconnection
+	 * involves communication, it might happen that we get a packet without
+	 * actually being connected any longer - in that case, silently forget it
+	 */
+	if(!receiver.isNull())
+	{
+		// put it into a custom data message and send it to the receiver
+		Buffer *buffer = receiver._allocCustomMessage(receiveHandlerID);
+		dp->write(*buffer);
+		receiver._sendCustomMessage(buffer);
+	}
+}
+
+void ASyncNetSend::processed()
+{
+	assert(!pqueue.empty());
+	pqueue.front()->processed();
+	pqueue.pop();
+}
+
+void ASyncNetSend::setReceiver(FlowSystemReceiver newReceiver)
+{
+	receiver = newReceiver;
+	receiveHandlerID = newReceiver.receiveHandlerID();
+}
+
+void ASyncNetSend::disconnect()
+{
+	/* since disconnection will cause destruction (most likely immediate),
+	 * we'll reference ourselves ...  */
+	_copy();
+
+	if(!receiver.isNull())
+	{
+		FlowSystemReceiver r = receiver;
+		receiver = FlowSystemReceiver::null();
+		r.disconnect();
+	}
+	if(ap)
+	{
+		ap->removeSendNet(this);
+		ap = 0;
+	}
+	
+	_release();
+}
+
+string ASyncNetSend::dest()
+{
+	return _dest;
+}
+
+/* dispatching function for custom message */
+
+static void _dispatch_ASyncNetReceive_receive(void *object, Buffer *buffer)
+{
+	((ASyncNetReceive *)object)->receive(buffer);
+}
+
+ASyncNetReceive::ASyncNetReceive(ASyncPort *port, FlowSystemSender sender)
+{
+	port->setNetReceiver(this);
+	stream = port->receiveNetCreateStream();
+	stream->channel = this;
+	this->sender = sender;
+	/* stream->_notifyID = _mkNotifyID(); */
+
+	gotPacketNotification.ID = port->receiveNetNotifyID();
+	gotPacketNotification.receiver = port->receiveNetObject();
+	gotPacketNotification.internal = 0;
+	_receiveHandlerID =
+		_addCustomMessageHandler(_dispatch_ASyncNetReceive_receive,this);
+}
+
+ASyncNetReceive::~ASyncNetReceive()
+{
+	/* tell outstanding packets that we don't exist any longer */
+	while(!sent.empty())
+	{
+		sent.front()->channel = 0;
+		sent.pop_front();
+	}
+	delete stream;
+}
+
+long ASyncNetReceive::receiveHandlerID()
+{
+	return _receiveHandlerID;
+}
+
+void ASyncNetReceive::receive(Buffer *buffer)
+{
+	GenericDataPacket *dp = stream->createPacket(512);
+	dp->read(*buffer);
+	dp->useCount = 1;
+	gotPacketNotification.data = dp;
+	NotificationManager::the()->send(gotPacketNotification);
+	sent.push_back(dp);
+}
+
+/*
+ * It will happen that this routine is called in time critical situations,
+ * such as: while audio calculation is running, and must be finished in
+ * time. The routine is mostly harmless, because sender->processed() is
+ * a oneway function, which just queues the buffer for sending and returns
+ * back, so it should return at once.
+ *
+ * However there is an exception upon first call: when sender->processed()
+ * is called for the first time, the method processed has still to be looked
+ * up. Thus, a synchronous call to _lookupMethod is made. That means, upon
+ * first call, the method will send out an MCOP request and block until the
+ * remote process tells that id.
+ */
+void ASyncNetReceive::processedPacket(GenericDataPacket *packet)
+{
+	/*
+	 * HACK! Upon disconnect, strange things will happen. One of them is
+	 * that we might, for the reason of not being referenced any longer,
+	 * cease to exist without warning. Another is that our nice "sender"
+	 * reference will get a null reference without warning, see disconnect
+	 * code (which will cause the attached stub to also disappear). As
+	 * those objects (especially the stub) are not prepared for not
+	 * being there any more in the middle of whatever they do, we here
+	 * explicitly reference us, and them, *again*, so that no evil things
+	 * will happen. A general solution for this would be garbage collection
+	 * in a timer, but until this is implemented (if it ever will become
+	 * implemented), we'll live with this hack.
+	 */
+	_copy();
+	sent.remove(packet);
+	stream->freePacket(packet);
+	if(!sender.isNull())
+	{
+		FlowSystemSender xsender = sender;
+		xsender.processed();
+	}
+	_release();
+}
+
+void ASyncNetReceive::disconnect()
+{
+	if(!sender.isNull())
+	{
+		FlowSystemSender s = sender;
+		sender = FlowSystemSender::null();
+		s.disconnect();
+	}
+}
+
+void ASyncNetReceive::sendPacket(GenericDataPacket *)
+{
+	assert(false);
+}
+
+void ASyncNetReceive::setPull(int, int)
+{
+	assert(false);
+}
+
+void ASyncNetReceive::endPull()
+{
+	assert(false);
+}
diff --git a/flow/asyncschedule.h b/flow/asyncschedule.h
new file mode 100644
index 0000000..0477c9a
--- /dev/null
+++ b/flow/asyncschedule.h
@@ -0,0 +1,134 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef ASYNCSCHEDULE_H
+#define ASYNCSCHEDULE_H
+
+#include "gslschedule.h"
+#include "datapacket.h"
+#include "weakreference.h"
+
+#include <queue>
+
+/*
+ * BC - Status (2002-03-08): ASyncNetSend, ASyncNetReceive, ASyncPort.
+ *
+ * None of these classes is considered part of the public API. Do NOT use it
+ * in your apps. These are part of the implementation of libartsflow's
+ * StdFlowSystem, and subject to change with the needs of it.
+ */
+
+namespace Arts {
+
+class ASyncPort;
+class ASyncNetSend : public FlowSystemSender_skel
+{
+protected:
+	ASyncPort *ap;
+	std::queue<GenericDataPacket *> pqueue;
+	FlowSystemReceiver receiver;
+	long receiveHandlerID;
+	std::string _dest;
+
+public:
+	ASyncNetSend(ASyncPort *ap, const std::string& dest);
+	~ASyncNetSend();
+	long notifyID();
+	std::string dest();
+
+	/* this overwrites the Object::notify function */
+	void notify(const Notification& notification);
+	void processed();
+	void setReceiver(FlowSystemReceiver receiver);
+	void disconnect();
+};
+
+class ASyncNetReceive : public FlowSystemReceiver_skel,
+						public GenericDataChannel
+{
+protected:
+	GenericAsyncStream *stream;
+	FlowSystemSender sender;
+	Notification gotPacketNotification;
+	std::list<GenericDataPacket *> sent;
+	long _receiveHandlerID;
+
+public:
+	ASyncNetReceive(ASyncPort *port, FlowSystemSender sender);
+	~ASyncNetReceive();
+
+	// GenericDataChannel interface
+	void processedPacket(GenericDataPacket *packet);
+	void sendPacket(GenericDataPacket *packet);
+	void setPull(int packets, int capacity);
+	void endPull();
+
+	// FlowSystemReceiver interface
+	
+	long receiveHandlerID();
+	void disconnect();
+	void receive(Buffer *buffer);	// custom data receiver
+};
+
+class ASyncPort :public Port, public GenericDataChannel {
+protected:
+	long notifyID;
+	std::vector<Notification> subscribers;
+	std::list<GenericDataPacket *> sent;
+	std::list<ASyncNetSend *> netSenders;
+	WeakReference<FlowSystemReceiver> netReceiver;
+
+	GenericAsyncStream *stream;
+
+	bool pull;
+	Notification pullNotification;
+
+public:
+	// GenericDataChannel interface
+	void processedPacket(GenericDataPacket *packet);
+	void sendPacket(GenericDataPacket *packet);
+	void setPull(int packets, int capacity);
+	void endPull();
+
+	// Port interface
+	ASyncPort(const std::string& name, void *ptr, long flags,
+			  StdScheduleNode* parent);
+	~ASyncPort();
+
+	void connect(Port *port);
+	void disconnect(Port *port);
+	ASyncPort *asyncPort();
+
+	// Network transparency
+	void addSendNet(ASyncNetSend *netsend);			// send
+	void removeSendNet(ASyncNetSend *netsend);
+	void disconnectRemote(const std::string& dest);
+
+	long receiveNetNotifyID();						// receive
+	GenericAsyncStream *receiveNetCreateStream();
+	NotificationClient *receiveNetObject();
+	void setNetReceiver(ASyncNetReceive *receiver);
+};
+
+}
+
+#endif /* ASYNCSCHEDULE_H */
diff --git a/flow/audioio.cc b/flow/audioio.cc
new file mode 100644
index 0000000..e5924ab
--- /dev/null
+++ b/flow/audioio.cc
@@ -0,0 +1,165 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "audioio.h"
+#include <map>
+#include <list>
+#include <assert.h>
+#include <cstring>
+
+using namespace Arts;
+using namespace std;
+
+class Arts::AudioIOPrivate {
+public:
+	map<AudioIO::AudioParam, int> paramMap;
+	map<AudioIO::AudioParam, string> paramStrMap;
+};
+
+AudioIO::AudioIO() :d(new AudioIOPrivate)
+{
+}
+
+AudioIO::~AudioIO()
+{
+	delete d;
+}
+
+int& AudioIO::param(AudioParam param)
+{
+	/*
+	 * returns d->paramMap[param], initializes new elements with -1 (for those
+	 * parameters not handled explicitly by the derived AudioIO* class).
+	 */
+
+	map<AudioIO::AudioParam, int>::iterator pi = d->paramMap.find(param);
+	if(pi == d->paramMap.end())
+	{
+		int& result = d->paramMap[param];
+		result = -1;
+		return result;
+	}
+	else return pi->second;
+}
+
+string& AudioIO::paramStr(AudioParam param)
+{
+	return d->paramStrMap[param];
+}
+
+void AudioIO::setParamStr(AudioParam p, const char *value)
+{
+	paramStr(p) = value;
+}
+
+void AudioIO::setParam(AudioParam p, int& value)
+{
+	param(p) = value;
+}
+
+int AudioIO::getParam(AudioParam p)
+{
+	return param(p);
+}
+
+const char *AudioIO::getParamStr(AudioParam p)
+{
+	return paramStr(p).c_str();
+}
+
+/* ---- factories ---- */
+
+static list<AudioIOFactory *> *audioIOFactories = 0;
+
+AudioIO *AudioIO::createAudioIO(const char *name)
+{
+	if(audioIOFactories)
+	{
+		list<AudioIOFactory *>::iterator i;
+		for(i = audioIOFactories->begin(); i != audioIOFactories->end(); i++)
+		{
+			AudioIOFactory *factory = *i;
+
+			if(strcmp(factory->name(),name) == 0)
+				return factory->createAudioIO();
+		}
+	}
+	return 0;
+}
+
+int AudioIO::queryAudioIOCount()
+{
+	return audioIOFactories->size();
+}
+
+int AudioIO::queryAudioIOParam(int /*audioIO*/, AudioParam /*p*/)
+{
+	return 0;
+}
+
+const char *AudioIO::queryAudioIOParamStr(int audioIO, AudioParam p)
+{
+	list<AudioIOFactory *>::iterator i = audioIOFactories->begin();
+
+	while(audioIO && i != audioIOFactories->end()) { i++; audioIO--; }
+	if(i == audioIOFactories->end()) return 0;
+	
+	switch(p)
+	{
+		case name:	
+			return (*i)->name();
+		case fullName:
+			return (*i)->fullName();
+		default:
+			return 0;
+	}
+}
+
+void AudioIO::addFactory(AudioIOFactory *factory)
+{
+	if(!audioIOFactories)
+		audioIOFactories = new list<AudioIOFactory *>;
+	
+	audioIOFactories->push_back(factory);
+}
+
+void AudioIO::removeFactory(AudioIOFactory *factory)
+{
+	assert(audioIOFactories);
+
+	audioIOFactories->remove(factory);
+	if(audioIOFactories->empty())
+	{
+		delete audioIOFactories;
+		audioIOFactories = 0;
+	}
+}
+
+void AudioIOFactory::startup()
+{
+	AudioIO::addFactory(this);
+}
+
+void AudioIOFactory::shutdown()
+{
+	AudioIO::removeFactory(this);
+}
diff --git a/flow/audioio.h b/flow/audioio.h
new file mode 100644
index 0000000..ade96e2
--- /dev/null
+++ b/flow/audioio.h
@@ -0,0 +1,145 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef ARTS_AUDIOIO_H
+#define ARTS_AUDIOIO_H
+
+#include <startupmanager.h>
+#include <string>
+#include "arts_export.h"
+/*
+ * BC - Status (2002-03-08): AudioIO, AudioIOFactory
+ *
+ * Right now, these classes are considered an implementation detail. No binary
+ * compatibility guaranteed, its safe to add virtual methods when required.
+ */
+
+/*
+ * The AudioIO class - it is used as follows:
+ *
+ *   1. check the settings with getParam, modify what you don't like
+ *   2. call open -> print getInfo(lastError) if it failed (returned false)
+ *   3. check whether the settings are still what you expected them to
+ *      be (as the AudioIO class will maybe only know after open if the
+ *      requested parameters can be achieved)
+ */
+
+namespace Arts {
+
+class AudioIOPrivate;
+class AudioIOFactory;
+
+class ARTS_EXPORT AudioIO {
+private:
+	class AudioIOPrivate *d;
+
+public:
+	enum AudioParam {
+/* the following has to be supported */
+		samplingRate = 1,	/* usually 4000..48000 (Hz) */
+		channels = 2,		/* usually 1 (mono) or 2 (stereo) */
+		format = 3,			/*	8  = 8bit unsigned
+							 *  16 = 16bit signed little endian
+							 *	17 = 16bit signed big endian
+							 *  32 = 32bit float */
+
+/* the following -can- be supported (value=-1 if they are not) */
+		direction = 101,	/* 1 = read, 2 = write, 3 = read|write */
+		fragmentCount = 102,/* usually 3..16 (to control latency) */
+		fragmentSize = 103,	/* usually 256,512,...8192 (a 2^N value) */
+		canRead = 104,		/* the amount of bytes that can be read */
+		canWrite = 105,		/* the amount of bytes that can be written */
+		selectReadFD = 106,	/* filedescriptor to be select()ed on for reading */
+		selectWriteFD = 107,/* filedescriptor to be select()ed on for writing */
+		autoDetect = 108,	/* 0 = don't use this as default 
+							 * 1 or higher = preference of using this as default
+							 *
+							 * if nothing else is specified, aRts asks all
+							 * available AudioIO classes for the autoDetect
+							 * value and chooses the one which returned the
+							 * highest number */
+
+/* string parameters that have to be supported */
+		lastError = 201,	/* the last error message as human readable text */
+
+/* string parameters that -can- be supported */
+		deviceName = 301,	/* name of the device to open */
+
+/* class parameters: same semantics as above */
+		name = 1201,		/* name of the driver (i.e. oss) */
+		fullName = 1202		/* full name (i.e. Open Sound System) */
+	};
+
+	enum {
+		directionRead = 1,
+		directionWrite = 2,
+		directionReadWrite = 3
+	};
+
+	AudioIO();
+	virtual ~AudioIO();
+
+	virtual void setParamStr(AudioParam param, const char *value);
+	virtual void setParam(AudioParam param, int& value);
+	virtual int getParam(AudioParam param);
+	virtual const char *getParamStr(AudioParam param);
+
+	virtual bool open() = 0;
+	virtual void close() = 0;
+	virtual int read(void *buffer, int size) = 0;
+	virtual int write(void *buffer, int size) = 0;
+
+/* ---- factory querying stuff ---- */
+	static int queryAudioIOCount();
+	static int queryAudioIOParam(int audioIO, AudioParam param);
+	static const char *queryAudioIOParamStr(int audioIO, AudioParam param);
+
+/* ---- factory stuff ---- */
+	static AudioIO *createAudioIO(const char *name);
+	static void addFactory(AudioIOFactory *factory);
+	static void removeFactory(AudioIOFactory *factory);
+
+protected:
+	int& param(AudioParam param);
+	std::string& paramStr(AudioParam param);
+};
+
+class ARTS_EXPORT AudioIOFactory : public StartupClass {
+public:
+	void startup();
+	void shutdown();
+	virtual AudioIO *createAudioIO() = 0;
+	virtual const char *name() = 0;
+	virtual const char *fullName() = 0;
+};
+
+}
+
+#define REGISTER_AUDIO_IO(impl,implName,implFullName)				\
+	static class AudioIOFactory ## impl : public AudioIOFactory {	\
+	public:															\
+		AudioIO *createAudioIO() { return new impl(); }				\
+		virtual const char *name() { return implName; }				\
+		virtual const char *fullName() { return implFullName; }		\
+	} The_ ## impl ## _Factory /* <- add semicolon when calling this macro */
+
+#endif /* ARTS_AUDIOIO_H */
diff --git a/flow/audioioaix.cc b/flow/audioioaix.cc
new file mode 100644
index 0000000..f36e9db
--- /dev/null
+++ b/flow/audioioaix.cc
@@ -0,0 +1,390 @@
+/*
+
+    Copyright (C) 2001 Carsten Griwodz
+                       griff@ifi.uio.no
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef _AIX
+
+/*
+ * The audio header files exist even if there is not soundcard the
+ * the AIX machine. You won't be able to compile this code on AIX3
+ * which had ACPA support, so /dev/acpa is not checked here.
+ * I have no idea whether the Ultimedia Audio Adapter is actually
+ * working or what it is right now.
+ * For PCI machines including PowerSeries 850, baud or paud should
+ * work. The DSP (MWave?) of the 850 laptops may need microcode
+ * download. This is not implemented.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/machine.h>
+#undef BIG_ENDIAN
+#include <sys/audio.h>
+
+#ifndef AUDIO_BIG_ENDIAN
+#define AUDIO_BIG_ENDIAN BIG_ENDIAN
+#endif
+
+#include "debug.h"
+#include "audioio.h"
+
+namespace Arts {
+
+class AudioIOAIX : public AudioIO {
+    int openDevice();
+
+protected:
+    int audio_fd;
+
+public:
+    AudioIOAIX();
+
+    void setParam(AudioParam param, int& value);
+    int getParam(AudioParam param);
+
+    bool open();
+    void close();
+    int read(void *buffer, int size);
+    int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIOAIX,"paud","Personal Audio Device");
+};
+
+using namespace std;
+using namespace Arts;
+
+int AudioIOAIX::openDevice()
+{
+	char devname[14];
+	int  fd;
+	for ( int dev=0; dev<4; dev++ )
+	{
+		for ( int chan=1; chan<8; chan++ )
+		{
+			sprintf(devname,"/dev/paud%d/%d",dev,chan);
+			fd = ::open (devname, O_WRONLY, 0);
+			if ( fd >= 0 )
+			{
+				paramStr(deviceName) = devname;
+				return fd;
+			}
+			sprintf(devname,"/dev/baud%d/%d",dev,chan);
+			fd = ::open (devname, O_WRONLY, 0);
+			if ( fd >= 0 )
+			{
+				paramStr(deviceName) = devname;
+				return fd;
+			}
+		}
+	}
+	return -1;
+}
+
+AudioIOAIX::AudioIOAIX()
+{
+	int fd = openDevice();
+	if( fd >= 0 )
+	{
+		audio_status audioStatus;
+		memset( &audioStatus, 0, sizeof(audio_status) );
+		ioctl(fd, AUDIO_STATUS, &audioStatus);
+
+		audio_buffer audioBuffer;
+		memset( &audioBuffer, 0, sizeof(audio_buffer) );
+		ioctl(fd, AUDIO_BUFFER, &audioBuffer);
+
+		::close( fd );
+
+		/*
+		 * default parameters
+		 */
+		param(samplingRate)  = audioStatus.srate;
+		param(fragmentSize)  = audioStatus.bsize;
+		param(fragmentCount) = audioBuffer.write_buf_cap / audioStatus.bsize;
+		param(channels)      = audioStatus.channels;
+		param(direction)     = 2;
+
+		param(format)        = ( audioStatus.bits_per_sample==8 ) ? 8
+			: ( ( audioStatus.flags & AUDIO_BIG_ENDIAN ) ? 17 : 16 );
+	}
+}
+
+bool AudioIOAIX::open()
+{
+	string& _error = paramStr(lastError);
+	string& _deviceName = paramStr(deviceName);
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+
+	int mode;
+
+	switch( param(direction) )
+	{
+		case 1 : mode = O_RDONLY | O_NDELAY; break;
+		case 2 : mode = O_WRONLY | O_NDELAY; break;
+		case 3 :
+				 _error = "open device twice to RDWR";
+				 return false;
+		default :
+				 _error = "invalid direction";
+				 return false;
+	}
+
+	audio_fd = ::open(_deviceName.c_str(), mode, 0);
+
+	if(audio_fd == -1)
+	{
+		_error = "device ";
+		_error += _deviceName.c_str();
+		_error += " can't be opened (";
+		_error += strerror(errno);
+		_error += ")";
+		return false;
+	}
+
+	if( (_channels!=1) && (_channels!=2) )
+	{
+		_error = "internal error; set channels to 1 (mono) or 2 (stereo)";
+
+		close();
+		return false;
+	}
+
+	// int requeststereo = stereo;
+
+	// int speed = _samplingRate;
+
+	audio_init audioInit;
+	memset( &audioInit, 0, sizeof(audio_init) );
+	audioInit.srate = _samplingRate;
+	audioInit.bits_per_sample = ((_format==8)?8:16);
+	audioInit.bsize = _fragmentSize;
+	audioInit.mode = PCM;
+	audioInit.channels = _channels;
+	audioInit.flags = 0;
+	audioInit.flags |= (_format==17) ? AUDIO_BIG_ENDIAN : 0;
+	audioInit.flags |= (_format==8)  ? 0 : SIGNED;
+	audioInit.operation = (param(direction)==1) ? RECORD : PLAY;
+
+	if ( ioctl(audio_fd, AUDIO_INIT, &audioInit) < 0 )
+	{
+		_error = "AUDIO_INIT failed - ";
+		_error += strerror(errno);
+		switch ( audioInit.rc )
+		{
+			case 1 :
+				_error += "Couldn't set audio format: DSP can't do play requests";
+				break;
+			case 2 :
+				_error += "Couldn't set audio format: DSP can't do record requests";
+				break;
+			case 4 :
+				_error += "Couldn't set audio format: request was invalid";
+				break;
+			case 5 :
+				_error += "Couldn't set audio format: conflict with open's flags";
+				break;
+			case 6 :
+				_error += "Couldn't set audio format: out of DSP MIPS or memory";
+				break;
+			default :
+				_error += "Couldn't set audio format: not documented in sys/audio.h";
+				break;
+		}
+
+		close();
+		return false;
+	}
+
+	if (audioInit.channels != _channels)
+	{
+		_error = "audio device doesn't support number of requested channels";
+		close();
+		return false;
+	}
+
+	switch( _format )
+	{
+		case 8 :
+			if (audioInit.flags&AUDIO_BIG_ENDIAN==1)
+			{
+				_error = "setting little endian format failed";
+				close();
+				return false;
+			}
+			if (audioInit.flags&SIGNED==1)
+			{
+				_error = "setting unsigned format failed";
+				close();
+				return false;
+			}
+			break;
+		case 16 :
+			if (audioInit.flags&AUDIO_BIG_ENDIAN==1)
+			{
+				_error = "setting little endian format failed";
+				close();
+				return false;
+			}
+			if (audioInit.flags&SIGNED==0)
+			{
+				_error = "setting signed format failed";
+				close();
+				return false;
+			}
+			break;
+		case 17 :
+			if (audioInit.flags&AUDIO_BIG_ENDIAN==0)
+			{
+				_error = "setting big endian format failed";
+				close();
+				return false;
+			}
+			if (audioInit.flags&SIGNED==0)
+			{
+				_error = "setting signed format failed";
+				close();
+				return false;
+			}
+			break;
+		default :
+			break;
+	}
+
+	/*
+	 * Some soundcards seem to be able to only supply "nearly" the requested
+	 * sampling rate, especially PAS 16 cards seem to quite radical supplying
+	 * something different than the requested sampling rate ;)
+	 *
+	 * So we have a quite large tolerance here (when requesting 44100 Hz, it
+	 * will accept anything between 38690 Hz and 49510 Hz). Most parts of the
+	 * aRts code will do resampling where appropriate, so it shouldn't affect
+	 * sound quality.
+	 */
+	int tolerance = _samplingRate/10+1000;
+
+	if (abs(audioInit.srate - _samplingRate) > tolerance)
+	{  
+		_error = "can't set requested samplingrate";
+
+		char details[80];
+		sprintf(details," (requested rate %d, got rate %ld)",
+				_samplingRate, audioInit.srate);
+		_error += details;
+
+		close();
+		return false;
+	} 
+	_samplingRate = audioInit.srate;
+
+	_fragmentSize = audioInit.bsize;
+	_fragmentCount = audioInit.bsize / audioInit.bits_per_sample;
+
+	audio_buffer buffer_info;
+	ioctl(audio_fd, AUDIO_BUFFER, &buffer_info);
+	_fragmentCount = buffer_info.write_buf_cap / audioInit.bsize;
+
+
+	artsdebug("buffering: %d fragments with %d bytes "
+			"(audio latency is %1.1f ms)", _fragmentCount, _fragmentSize,
+			(float)(_fragmentSize*_fragmentCount) /
+			(float)(2.0 * _samplingRate * _channels)*1000.0);
+
+	return true;
+}
+
+void AudioIOAIX::close()
+{
+	::close(audio_fd);
+}
+
+void AudioIOAIX::setParam(AudioParam p, int& value)
+{
+	param(p) = value;
+}
+
+int AudioIOAIX::getParam(AudioParam p)
+{
+	audio_buffer info;
+	switch(p)
+	{
+		case canRead:
+			ioctl(audio_fd, AUDIO_BUFFER, &info);
+			return (info.read_buf_cap - info.read_buf_size);
+			break;
+
+		case canWrite:
+			ioctl(audio_fd, AUDIO_BUFFER, &info);
+			return (info.write_buf_cap - info.write_buf_size);
+			break;
+
+		case selectReadFD:
+			return (param(direction) & directionRead)?audio_fd:-1;
+			break;
+
+		case selectWriteFD:
+			return (param(direction) & directionWrite)?audio_fd:-1;
+			break;
+
+		case autoDetect:
+			/* You may prefer OSS if it works, e.g. on 43P 240
+			 * or you may prefer UMS, if anyone bothers to write
+			 * a module for it.
+			 */
+			return 2;
+			break;
+
+		default:
+			return param(p);
+			break;
+	}
+}
+
+int AudioIOAIX::read(void *buffer, int size)
+{
+	arts_assert(audio_fd != 0);
+	return ::read(audio_fd,buffer,size);
+}
+
+int AudioIOAIX::write(void *buffer, int size)
+{
+	arts_assert(audio_fd != 0);
+	return ::write(audio_fd,buffer,size);
+}
+
+#endif
+
diff --git a/flow/audioioalsa.cc b/flow/audioioalsa.cc
new file mode 100644
index 0000000..303db16
--- /dev/null
+++ b/flow/audioioalsa.cc
@@ -0,0 +1,561 @@
+    /*
+
+    Copyright (C) 2000,2001 Jozef Kosoru
+                            jozef.kosoru@pobox.sk
+			  (C) 2000,2001 Stefan Westerfeld
+			                stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+ * only compile 'alsa' AudioIO class if configure thinks it is a good idea
+ */
+#ifdef HAVE_LIBASOUND
+
+#ifdef HAVE_ALSA_ASOUNDLIB_H
+#include <alsa/asoundlib.h>
+#elif defined(HAVE_SYS_ASOUNDLIB_H)
+#include <sys/asoundlib.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>		// Needed on some systems.
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+
+#include "debug.h"
+#include "audioio.h"
+
+namespace Arts {
+
+class AudioIOALSA : public AudioIO {
+protected:
+	int audio_read_fd;
+	int audio_write_fd;
+	int requestedFragmentSize;
+	int requestedFragmentCount;
+
+	enum BufferMode{block, stream};
+	int m_card;
+	int m_device;
+	int m_format;
+	BufferMode m_bufferMode;
+
+	snd_pcm_t *m_pcm_handle;
+	snd_pcm_channel_info_t m_cinfo;
+	snd_pcm_format_t m_cformat;
+	snd_pcm_channel_params_t m_params;
+	snd_pcm_channel_setup_t m_setup;
+
+	int setPcmParams(const int channel);
+	void checkCapabilities();
+
+public:
+	AudioIOALSA();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIOALSA,"alsa","Advanced Linux Sound Architecture");
+};
+
+using namespace std;
+using namespace Arts;
+
+AudioIOALSA::AudioIOALSA()
+{
+ 	param(samplingRate) = 44100;
+	paramStr(deviceName) = "/dev/dsp"; //!! alsa doesn't need this
+	requestedFragmentSize = param(fragmentSize) = 1024;
+	requestedFragmentCount = param(fragmentCount) = 7;
+	param(channels) = 2;
+	param(direction) = directionWrite;
+
+	/*
+	 * default parameters
+	 */
+    m_card = snd_defaults_pcm_card();  //!! need interface !!
+    m_device = snd_defaults_pcm_device(); //!!
+#ifdef WORDS_BIGENDIAN
+    m_format = SND_PCM_SFMT_S16_BE;
+#else
+    m_format = SND_PCM_SFMT_S16_LE;
+#endif
+    m_bufferMode = block;  //block/stream (stream mode doesn't work yet)
+
+	if(m_card >= 0) {
+    	char* cardname = 0;
+
+    	if(snd_card_get_name(m_card, &cardname) == 0 && cardname != 0)
+		{
+			//!! thats not what devicename is intended to do
+			//!! devicename is an input information into
+			//!! the "driver", to select which card to use
+			//!! not an output information
+    		paramStr(deviceName) = cardname;
+    		free(cardname);
+		}
+	}
+}
+
+bool AudioIOALSA::open()
+{
+	string& _error = paramStr(lastError);
+	string& _deviceName = paramStr(deviceName);
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _direction = param(direction);
+	int& _format = param(format);
+
+	/*
+	 * initialize format - TODO: implement fallback (i.e. if no format given,
+	 * it should try 16bit first, then fall back to 8bit)
+	 */
+	switch(_format)
+	{
+		default:	_format = 16;
+
+		case 16:	// 16bit, signed little endian
+				m_format = SND_PCM_SFMT_S16_LE;
+			break;
+
+		case 17:	// 16bit, signed big endian
+				m_format = SND_PCM_SFMT_S16_BE;
+			break;
+
+		case 8:		// 8bit, unsigned
+				m_format = SND_PCM_SFMT_U8;
+			break;
+	}
+
+	/* open pcm device */
+	int mode = SND_PCM_OPEN_NONBLOCK;
+
+	if(_direction == directionReadWrite)
+    	mode |= SND_PCM_OPEN_DUPLEX;
+	else if(_direction == directionWrite)
+    	mode |= SND_PCM_OPEN_PLAYBACK;
+	else
+	{
+		_error = "invalid direction";
+		return false;
+	}
+
+	int err;
+	if((err = snd_pcm_open(&m_pcm_handle, m_card, m_device, mode)) < 0) {
+		_error = "device: ";
+		_error += _deviceName.c_str();
+		_error += " can't be opened (";
+		_error += snd_strerror(err);
+		_error += ")";
+		return false;
+	}
+	else {
+		artsdebug("ALSA driver: %s", _deviceName.c_str());
+	}
+
+	snd_pcm_nonblock_mode(m_pcm_handle, 0);
+
+	/* flush buffers */
+	(void)snd_pcm_capture_flush(m_pcm_handle);
+	if(_direction & directionRead)
+		(void)snd_pcm_channel_flush(m_pcm_handle, SND_PCM_CHANNEL_CAPTURE);
+	if(_direction & directionWrite)
+		(void)snd_pcm_channel_flush(m_pcm_handle, SND_PCM_CHANNEL_PLAYBACK);
+
+	/* check device capabilities */
+	checkCapabilities();
+
+	/* set the fragment settings to what the user requested */
+	_fragmentSize = requestedFragmentSize;
+	_fragmentCount = requestedFragmentCount;
+
+  	/* set PCM communication parameters */
+  	if((_direction & directionRead) && setPcmParams(SND_PCM_CHANNEL_CAPTURE))
+		return false;
+  	if((_direction & directionWrite) && setPcmParams(SND_PCM_CHANNEL_PLAYBACK))
+		return false;
+
+  	/* prepare channel */
+    if((_direction & directionRead) &&
+		snd_pcm_channel_prepare(m_pcm_handle, SND_PCM_CHANNEL_CAPTURE) < 0)
+	{
+      	_error = "Unable to prepare capture channel!";
+		return false;
+    }
+    if((_direction & directionWrite) &&
+    	snd_pcm_channel_prepare(m_pcm_handle, SND_PCM_CHANNEL_PLAYBACK) < 0)
+	{
+    	_error = "Unable to prepare playback channel!";
+	  	return false;
+    }
+
+	/* obtain current PCM setup (may differ from requested one) */
+	(void)memset(&m_setup, 0, sizeof(m_setup));
+
+	m_setup.channel = SND_PCM_CHANNEL_PLAYBACK;
+	if(snd_pcm_channel_setup(m_pcm_handle, &m_setup) < 0) {
+    	_error = "Unable to obtain channel setup!";
+		return false;
+	}
+
+	/* check samplerate */
+	const int tolerance = _samplingRate/10+1000;
+	if(abs(m_setup.format.rate-_samplingRate) > tolerance)
+	{
+		_error = "Can't set requested sampling rate!";
+		char details[80];
+		sprintf(details," (requested rate %d, got rate %d)",
+            _samplingRate, m_setup.format.rate);
+    	_error += details;
+		return false;
+  	}
+	_samplingRate = m_setup.format.rate;
+
+	/* check format */
+	if(m_setup.format.format != m_format) {
+    	_error = "Can't set requested format:";
+    	_error += snd_pcm_get_format_name(m_format);
+		return false;
+	}
+
+	/* check voices */
+	if(m_setup.format.voices != _channels) {
+		_error = "Audio device doesn't support number of requested channels!";
+		return false;
+	}
+
+	/* update fragment settings with what we got */
+	switch(m_bufferMode) {
+		case block:
+      			_fragmentSize = m_setup.buf.block.frag_size;
+      			_fragmentCount = m_setup.buf.block.frags_max-1;
+      		break;
+    	case stream:
+      			_fragmentSize = m_setup.buf.stream.queue_size;
+      			_fragmentCount = 1;
+      		break;
+  	}
+
+  	artsdebug("buffering: %d fragments with %d bytes "
+            "(audio latency is %1.1f ms)", _fragmentCount, _fragmentSize,
+            (float)(_fragmentSize*_fragmentCount) /
+            (float)(2.0 * _samplingRate * _channels)*1000.0);
+
+  	/* obtain PCM file descriptor(s) */
+	audio_read_fd = audio_write_fd = -1;
+
+	if(_direction & directionRead)
+  		audio_read_fd = snd_pcm_file_descriptor(m_pcm_handle,
+												SND_PCM_CHANNEL_CAPTURE);
+	if(_direction & directionWrite)
+  		audio_write_fd = snd_pcm_file_descriptor(m_pcm_handle,
+												SND_PCM_CHANNEL_PLAYBACK);
+
+  	/* start recording */
+  	if((_direction & directionRead) && snd_pcm_capture_go(m_pcm_handle)) {
+    	_error = "Can't start recording!";
+		return false;
+  	}
+
+  	return true;
+}
+
+void AudioIOALSA::close()
+{
+	int& _direction = param(direction);
+	if(_direction & directionRead)
+		(void)snd_pcm_channel_flush(m_pcm_handle, SND_PCM_CHANNEL_CAPTURE);
+	if(_direction & directionWrite)
+		(void)snd_pcm_channel_flush(m_pcm_handle, SND_PCM_CHANNEL_PLAYBACK);
+	(void)snd_pcm_close(m_pcm_handle);
+}
+
+void AudioIOALSA::setParam(AudioParam p, int& value)
+{
+	switch(p)
+	{
+		case fragmentSize:
+				param(p) = requestedFragmentSize = value;
+			break;
+		case fragmentCount:
+				param(p) = requestedFragmentCount = value;
+			break;
+		default:
+				param(p) = value;
+			break;
+	}
+}
+
+int AudioIOALSA::getParam(AudioParam p)
+{
+    snd_pcm_channel_status_t status;
+    (void)memset(&status, 0, sizeof(status));
+
+	switch(p)
+	{
+		case canRead:
+      			status.channel = SND_PCM_CHANNEL_CAPTURE;
+      			if(snd_pcm_channel_status(m_pcm_handle, &status) < 0) {
+        			arts_warning("Capture channel status error!");
+        			return -1;
+      			}
+				return status.free;
+			break;
+
+		case canWrite:
+      			status.channel = SND_PCM_CHANNEL_PLAYBACK;
+      			if(snd_pcm_channel_status(m_pcm_handle, &status) < 0) {
+        			arts_warning("Playback channel status error!");
+        			return -1;
+      			}
+				return status.free;
+			break;
+
+		case selectReadFD:
+				return audio_read_fd;
+			break;
+
+		case selectWriteFD:
+				return audio_write_fd;
+			break;
+
+		case autoDetect:
+				/*
+				 * that the ALSA driver could be compiled doesn't say anything
+				 * about whether it will work (the user might be using an OSS
+				 * kernel driver) so we'll use a value less than the OSS one
+				 * here, because OSS will most certainly work (ALSA's OSS emu)
+				 */
+				return 5;
+			break;
+
+		default:
+				return param(p);
+			break;
+	}
+}
+
+int AudioIOALSA::read(void *buffer, int size)
+{
+	int length;
+	do {
+		length = snd_pcm_read(m_pcm_handle, buffer, size);
+	} while (length == -EINTR);
+	if(length == -EPIPE) {
+		snd_pcm_channel_status_t status;
+		(void)memset(&status, 0, sizeof(status));
+		status.channel = SND_PCM_CHANNEL_CAPTURE;
+		if(snd_pcm_channel_status(m_pcm_handle, &status) < 0) {
+			arts_info("Capture channel status error!");
+			return -1;
+		}
+		else if(status.status == SND_PCM_STATUS_RUNNING) {
+			length = 0;
+		}
+		else if(status.status == SND_PCM_STATUS_OVERRUN) {
+			artsdebug("Overrun at position: %d" ,status.scount);
+			if(snd_pcm_channel_prepare(m_pcm_handle, SND_PCM_CHANNEL_CAPTURE)<0)
+			{
+				arts_info("Overrun: capture prepare error!");
+				return -1;
+			}
+			length = 0;
+		}
+		else {
+			arts_info("Unknown capture error!");
+			return -1;
+		}
+	}
+    else if(length < 0) {
+		arts_info("Capture error: %s", snd_strerror(length));
+		return -1;
+	}
+	return length;
+}
+
+int AudioIOALSA::write(void *buffer, int size)
+{
+	int length;
+	while((length = snd_pcm_write(m_pcm_handle, buffer, size)) != size) {
+	if (length == -EINTR)
+		continue; // Try again
+        snd_pcm_channel_status_t status;
+        (void)memset(&status, 0, sizeof(status));
+        status.channel = SND_PCM_CHANNEL_PLAYBACK;
+
+        if(snd_pcm_channel_status(m_pcm_handle, &status) < 0) {
+        	arts_warning("Playback channel status error!");
+        	return -1;
+        }
+		else if(status.status == SND_PCM_STATUS_UNDERRUN) {
+        	artsdebug("Underrun at position: %d", status.scount);
+          	if(snd_pcm_channel_prepare(m_pcm_handle, SND_PCM_CHANNEL_PLAYBACK)
+														< 0) {
+            	arts_warning("Underrun: playback prepare error!");
+            	return -1;
+          	}
+        }
+        else {
+        	arts_warning("Unknown playback error!");
+        	return -1;
+        }
+    }
+	return size;
+}
+
+int AudioIOALSA::setPcmParams(const int channel)
+{
+	int &_samplingRate = param(samplingRate);
+	int &_channels = param(channels);
+	int &_fragmentSize = param(fragmentSize);
+	int &_fragmentCount = param(fragmentCount);
+
+	(void)memset(&m_cformat, 0, sizeof(m_cformat));
+	m_cformat.interleave = 1;
+	m_cformat.format = m_format;
+	m_cformat.rate = _samplingRate;
+	m_cformat.voices = _channels;
+
+	(void)memset(&m_params, 0, sizeof(m_params));
+	switch(m_bufferMode){
+		case stream:
+				m_params.mode=SND_PCM_MODE_STREAM;
+			break;
+		case block:
+				m_params.mode=SND_PCM_MODE_BLOCK;
+			break;
+	}
+	m_params.channel=channel;
+	(void)memcpy(&m_params.format, &m_cformat, sizeof(m_cformat));
+	if(channel==SND_PCM_CHANNEL_CAPTURE){
+		m_params.start_mode=SND_PCM_START_GO;
+		m_params.stop_mode=SND_PCM_STOP_ROLLOVER;
+	}
+	else{	//SND_PCM_CHANNEL_PLAYBACK
+		m_params.start_mode= (m_bufferMode==block) ? SND_PCM_START_FULL : SND_PCM_START_DATA;
+		m_params.stop_mode=SND_PCM_STOP_ROLLOVER;	// SND_PCM_STOP_STOP
+		//use this ^^^ if you want to track underruns
+	}
+
+	switch(m_bufferMode){
+		case stream:
+			m_params.buf.stream.queue_size=1024*1024; //_fragmentSize*_fragmentCount;
+			m_params.buf.stream.fill=SND_PCM_FILL_SILENCE_WHOLE;
+			m_params.buf.stream.max_fill=1024;
+		break;
+		case block:
+			m_params.buf.block.frag_size=_fragmentSize;
+			if(channel==SND_PCM_CHANNEL_CAPTURE){
+				m_params.buf.block.frags_max=1;
+				m_params.buf.block.frags_min=1;
+			}
+			else{	//SND_PCM_CHANNEL_PLAYBACK
+				m_params.buf.block.frags_max=_fragmentCount+1;
+				m_params.buf.block.frags_min=1;
+			}
+	}
+	if(snd_pcm_channel_params(m_pcm_handle, &m_params)<0){
+		paramStr(lastError) = "Unable to set channel params!";
+		return 1;
+	}
+	else {
+		return 0;
+	}
+}
+
+void AudioIOALSA::checkCapabilities()
+{
+	snd_pcm_info_t info;
+	(void)memset(&info, 0, sizeof(info));
+	if(!snd_pcm_info(m_pcm_handle, &info)) {
+		string flags = "";
+		if(info.flags & SND_PCM_INFO_PLAYBACK) flags += "playback ";
+		if(info.flags & SND_PCM_INFO_CAPTURE) flags += "capture ";
+		if(info.flags & SND_PCM_INFO_DUPLEX) flags += "duplex ";
+		if(info.flags & SND_PCM_INFO_DUPLEX_RATE) flags += "duplex_rate ";
+		artsdebug(" type:%d id:%s\n"
+							" flags:%s\n"
+							" playback_subdevices:%d capture_subdevices:%d",
+							info.type, info.id,
+							flags.c_str(),
+							info.playback+1, info.capture+1);
+	}
+	else {
+		arts_warning("Can't get device info!"); //not fatal error
+	}
+	
+	(void)memset(&m_cinfo, 0, sizeof(m_cinfo));
+	m_cinfo.channel = SND_PCM_CHANNEL_PLAYBACK;
+	if(!snd_pcm_channel_info(m_pcm_handle, &m_cinfo)) {
+		string flags = "";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_MMAP) flags += "mmap ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_STREAM) flags += "stream ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_BLOCK) flags += "block ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_BATCH) flags += "batch ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_INTERLEAVE) flags += "interleave ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_NONINTERLEAVE) flags += "noninterleave ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_BLOCK_TRANSFER) flags += "block_transfer ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_OVERRANGE) flags += "overrange ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_MMAP_VALID) flags += "mmap_valid ";
+		if(m_cinfo.flags & SND_PCM_CHNINFO_PAUSE) flags += "pause ";
+	
+		artsdebug(" subdevice:%d\n"
+				  "  flags:%s\n"
+				  "  min_rate:%d max_rate:%d\n"
+				  "  buffer_size:%d min_fragment_size:%d max_fragment_size:%d\n"
+				  "  fragment_align:%d fifo_size:%d transfer_block_size:%d\n"
+				  "  mmap_size:%d",
+				  m_cinfo.subdevice,
+				  flags.c_str(),
+				  m_cinfo.min_rate, m_cinfo.max_rate,
+				  m_cinfo.buffer_size, m_cinfo.min_fragment_size, m_cinfo.max_fragment_size,
+				  m_cinfo.fragment_align, m_cinfo.fifo_size, m_cinfo.transfer_block_size,
+				  m_cinfo.mmap_size);
+	}
+	else {
+		arts_warning("Can't get channel info!"); //not fatal error
+	}
+}
+
+#endif /* HAVE_LIBASOUND */
diff --git a/flow/audioioalsa9.cc b/flow/audioioalsa9.cc
new file mode 100644
index 0000000..8367da6
--- /dev/null
+++ b/flow/audioioalsa9.cc
@@ -0,0 +1,590 @@
+    /*
+
+    Copyright (C) 2001 Takashi Iwai <tiwai@suse.de>
+    Copyright (C) 2004 Allan Sandfeld Jensen <kde@carewolf.com>
+
+    based on audioalsa.cc:
+    Copyright (C) 2000,2001 Jozef Kosoru
+                            jozef.kosoru@pobox.sk
+			  (C) 2000,2001 Stefan Westerfeld
+			                stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+ * only compile 'alsa' AudioIO class if configure thinks it is a good idea
+ */
+#ifdef HAVE_LIBASOUND2
+
+#ifdef HAVE_ALSA_ASOUNDLIB_H
+#include <alsa/asoundlib.h>
+#elif defined(HAVE_SYS_ASOUNDLIB_H)
+#include <sys/asoundlib.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+
+#include "debug.h"
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "dispatcher.h"
+#include "iomanager.h"
+
+namespace Arts {
+
+class AudioIOALSA : public AudioIO, public IONotify  {
+protected:
+	// List of file descriptors
+        struct poll_descriptors {
+            poll_descriptors() : nfds(0), pfds(0) {};
+            int nfds;
+            struct pollfd *pfds;
+        } audio_write_pds, audio_read_pds;
+
+        snd_pcm_t *m_pcm_playback;
+	snd_pcm_t *m_pcm_capture;
+	snd_pcm_format_t m_format;
+	int m_period_size, m_periods;
+
+        void startIO();
+	int setPcmParams(snd_pcm_t *pcm);
+        static int poll2iomanager(int pollTypes);
+        static int iomanager2poll(int ioTypes);
+	void getDescriptors(snd_pcm_t *pcm, poll_descriptors *pds);
+	void watchDescriptors(poll_descriptors *pds);
+
+        void notifyIO(int fd, int types);
+
+	int xrun(snd_pcm_t *pcm);
+#ifdef HAVE_SND_PCM_RESUME
+	int resume(snd_pcm_t *pcm);
+#endif
+
+public:
+	AudioIOALSA();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIOALSA,"alsa","Advanced Linux Sound Architecture");
+}
+
+using namespace std;
+using namespace Arts;
+
+AudioIOALSA::AudioIOALSA()
+{
+ 	param(samplingRate) = 44100;
+	paramStr(deviceName) = "default"; // ALSA pcm device name - not file name
+	param(fragmentSize) = 1024;
+	param(fragmentCount) = 7;
+	param(channels) = 2;
+	param(direction) = directionWrite;
+        param(format) = 16;
+	/*
+	 * default parameters
+	 */
+	m_format = SND_PCM_FORMAT_S16_LE;
+        m_pcm_playback = NULL;
+	m_pcm_capture = NULL;
+}
+
+bool AudioIOALSA::open()
+{
+        string& _error = paramStr(lastError);
+	string& _deviceName = paramStr(deviceName);
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _direction = param(direction);
+	int& _format = param(format);
+
+	m_pcm_playback = NULL;
+	m_pcm_capture = NULL;
+
+	/* initialize format */
+	switch(_format) {
+	case 16:	// 16bit, signed little endian
+		m_format = SND_PCM_FORMAT_S16_LE;
+		break;
+	case 17:	// 16bit, signed big endian
+		m_format = SND_PCM_FORMAT_S16_BE;
+		break;
+	case 8:		// 8bit, unsigned
+		m_format = SND_PCM_FORMAT_U8;
+		break;
+	default:	// test later
+		m_format = SND_PCM_FORMAT_UNKNOWN;
+		break;
+	}
+
+	/* open pcm device */
+	int err;
+	if (_direction & directionWrite) {
+		if ((err = snd_pcm_open(&m_pcm_playback, _deviceName.c_str(),
+					SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) < 0) {
+			_error = "device: ";
+			_error += _deviceName.c_str();
+			_error += " can't be opened for playback (";
+			_error += snd_strerror(err);
+			_error += ")";
+			return false;
+		}
+		snd_pcm_nonblock(m_pcm_playback, 0);
+	}
+	if (_direction & directionRead) {
+		if ((err = snd_pcm_open(&m_pcm_capture, _deviceName.c_str(),
+					SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK)) < 0) {
+			_error = "device: ";
+			_error += _deviceName.c_str();
+			_error += " can't be opened for capture (";
+			_error += snd_strerror(err);
+			_error += ")";
+			snd_pcm_close(m_pcm_playback);
+			return false;
+		}
+		snd_pcm_nonblock(m_pcm_capture, 0);
+	}
+
+	artsdebug("ALSA driver: %s", _deviceName.c_str());
+
+	/* check device capabilities */
+	// checkCapabilities();
+
+	/* set PCM communication parameters */
+	if (((_direction & directionWrite) && setPcmParams(m_pcm_playback)) ||
+	    ((_direction & directionRead) && setPcmParams(m_pcm_capture))) {
+		snd_pcm_close(m_pcm_playback);
+		snd_pcm_close(m_pcm_capture);
+		return false;
+	}
+
+  	artsdebug("buffering: %d fragments with %d bytes "
+		  "(audio latency is %1.1f ms)", _fragmentCount, _fragmentSize,
+		  (float)(_fragmentSize*_fragmentCount) /
+		  (float)(2.0 * _samplingRate * _channels)*1000.0);
+
+
+	startIO();
+        /* restore the format value */
+	switch (m_format) {
+	case SND_PCM_FORMAT_S16_LE:
+		_format = 16;
+		break;
+	case SND_PCM_FORMAT_S16_BE:
+		_format = 17;
+		break;
+	case SND_PCM_FORMAT_U8:
+		_format =  8;
+		break;
+        default:
+            _error = "Unknown PCM format";
+            return false;
+	}
+
+	/* start recording */
+	if (_direction & directionRead)
+		snd_pcm_start(m_pcm_capture);
+
+	return true;
+}
+
+void AudioIOALSA::close()
+{
+        arts_debug("Closing ALSA-driver");
+	int& _direction = param(direction);
+	if ((_direction & directionRead) && m_pcm_capture) {
+		(void)snd_pcm_drop(m_pcm_capture);
+		(void)snd_pcm_close(m_pcm_capture);
+		m_pcm_capture = NULL;
+	}
+	if ((_direction & directionWrite) && m_pcm_playback) {
+		(void)snd_pcm_drop(m_pcm_playback);
+		(void)snd_pcm_close(m_pcm_playback);
+		m_pcm_playback = NULL;
+	}
+	Dispatcher::the()->ioManager()->remove(this, IOType::all);
+
+	delete[] audio_read_pds.pfds;
+	delete[] audio_write_pds.pfds;
+        audio_read_pds.pfds = NULL; audio_write_pds.pfds = NULL;
+        audio_read_pds.nfds = 0; audio_write_pds.nfds = 0;
+}
+
+void AudioIOALSA::setParam(AudioParam p, int& value)
+{
+	param(p) = value;
+        if (m_pcm_playback != NULL) {
+            setPcmParams(m_pcm_playback);
+        }
+        if (m_pcm_capture != NULL) {
+            setPcmParams(m_pcm_capture);
+        }
+}
+
+int AudioIOALSA::getParam(AudioParam p)
+{
+	snd_pcm_sframes_t avail;
+	switch(p) {
+
+        case canRead:
+		if (! m_pcm_capture) return -1;
+		while ((avail = snd_pcm_avail_update(m_pcm_capture)) < 0) {
+			if (avail == -EPIPE)
+				avail = xrun(m_pcm_capture);
+#ifdef HAVE_SND_PCM_RESUME
+			else if (avail == -ESTRPIPE)
+				avail = resume(m_pcm_capture);
+#endif
+			if (avail < 0) {
+				arts_info("Capture error: %s", snd_strerror(avail));
+				return -1;
+			}
+		}
+		return snd_pcm_frames_to_bytes(m_pcm_capture, avail);
+
+	case canWrite:
+		if (! m_pcm_playback) return -1;
+		while ((avail = snd_pcm_avail_update(m_pcm_playback)) < 0) {
+			if (avail == -EPIPE)
+				avail = xrun(m_pcm_playback);
+#ifdef HAVE_SND_PCM_RESUME
+			else if (avail == -ESTRPIPE)
+				avail = resume(m_pcm_playback);
+#endif
+			if (avail < 0) {
+				arts_info("Playback error: %s", snd_strerror(avail));
+				return -1;
+			}
+		}
+		return snd_pcm_frames_to_bytes(m_pcm_playback, avail);
+
+	case selectReadFD:
+		return -1;
+
+	case selectWriteFD:
+		return -1;
+
+	case autoDetect:
+	{
+		/*
+		 * that the ALSA driver could be compiled doesn't say anything
+		 * about whether it will work (the user might be using an OSS
+		 * kernel driver).
+		 * If we can open the device, it'll work - and we'll have to use
+		 * a higher number than OSS to avoid buggy OSS emulation being used.
+		 */
+		int card = -1;
+		if (snd_card_next(&card) < 0 || card < 0) {
+			// No ALSA drivers in use...
+			return 0;
+		}
+		return 15;
+	}
+
+	default:
+		return param(p);
+	}
+}
+
+void AudioIOALSA::startIO()
+{
+        /* get & watch PCM file descriptor(s) */
+	if (m_pcm_playback) {
+                getDescriptors(m_pcm_playback, &audio_write_pds);
+		watchDescriptors(&audio_write_pds);
+        }
+	if (m_pcm_capture) {
+                getDescriptors(m_pcm_capture, &audio_read_pds);
+		watchDescriptors(&audio_read_pds);
+        }
+
+}
+
+int AudioIOALSA::poll2iomanager(int pollTypes)
+{
+	int types = 0;
+
+	if(pollTypes & POLLIN)
+		types |= IOType::read;
+	if(pollTypes & POLLOUT)
+		types |= IOType::write;
+	if(pollTypes & POLLERR)
+		types |= IOType::except;
+
+	return types;
+}
+
+int AudioIOALSA::iomanager2poll(int ioTypes)
+{
+	int types = 0;
+
+	if(ioTypes & IOType::read)
+		types |= POLLIN;
+	if(ioTypes & IOType::write)
+		types |= POLLOUT;
+	if(ioTypes & IOType::except)
+		types |= POLLERR;
+
+	return types;
+}
+
+void AudioIOALSA::getDescriptors(snd_pcm_t *pcm, poll_descriptors *pds)
+{
+	pds->nfds = snd_pcm_poll_descriptors_count(pcm);
+	pds->pfds = new struct pollfd[pds->nfds];
+
+        if (snd_pcm_poll_descriptors(pcm, pds->pfds, pds->nfds) != pds->nfds) {
+		arts_info("Cannot get poll descriptor(s)\n");
+	}
+
+}
+
+void AudioIOALSA::watchDescriptors(poll_descriptors *pds)
+{
+	for(int i=0; i<pds->nfds; i++) {
+	        // Check in which direction this handle is supposed to be watched
+		int types = poll2iomanager(pds->pfds[i].events);
+		Dispatcher::the()->ioManager()->watchFD(pds->pfds[i].fd, types, this);
+	}
+}
+
+int AudioIOALSA::xrun(snd_pcm_t *pcm)
+{
+	int err;
+	artsdebug("xrun!!\n");
+	if ((err = snd_pcm_prepare(pcm)) < 0)
+		return err;
+	if (pcm == m_pcm_capture)
+		snd_pcm_start(pcm); // ignore error here..
+	return 0;
+}
+
+#ifdef HAVE_SND_PCM_RESUME
+int AudioIOALSA::resume(snd_pcm_t *pcm)
+{
+	int err;
+	artsdebug("resume!\n");
+	while ((err = snd_pcm_resume(pcm)) == -EAGAIN)
+		sleep(1); /* wait until suspend flag is not released */
+	if (err < 0) {
+		if ((err = snd_pcm_prepare(pcm)) < 0)
+			return err;
+		if (pcm == m_pcm_capture)
+			snd_pcm_start(pcm); // ignore error here..
+	}
+	return 0;
+}
+#endif
+
+int AudioIOALSA::read(void *buffer, int size)
+{
+	int frames = snd_pcm_bytes_to_frames(m_pcm_capture, size);
+	int length;
+	while ((length = snd_pcm_readi(m_pcm_capture, buffer, frames)) < 0) {
+		if (length == -EINTR)
+			continue; // Try again
+		else if (length == -EPIPE)
+			length = xrun(m_pcm_capture);
+#ifdef HAVE_SND_PCM_RESUME
+		else if (length == -ESTRPIPE)
+			length = resume(m_pcm_capture);
+#endif
+		if (length < 0) {
+			arts_info("Capture error: %s", snd_strerror(length));
+			return -1;
+		}
+	}
+	return snd_pcm_frames_to_bytes(m_pcm_capture, length);
+}
+
+int AudioIOALSA::write(void *buffer, int size)
+{
+        int frames = snd_pcm_bytes_to_frames(m_pcm_playback, size);
+	int length;
+	while ((length = snd_pcm_writei(m_pcm_playback, buffer, frames)) < 0) {
+		if (length == -EINTR)
+			continue; // Try again
+		else if (length == -EPIPE)
+			length = xrun(m_pcm_playback);
+#ifdef HAVE_SND_PCM_RESUME
+		else if (length == -ESTRPIPE)
+			length = resume(m_pcm_playback);
+#endif
+		if (length < 0) {
+			arts_info("Playback error: %s", snd_strerror(length));
+			return -1;
+		}
+	}
+
+	// Start the sink if it needs it
+	if (snd_pcm_state( m_pcm_playback ) == SND_PCM_STATE_PREPARED)
+		snd_pcm_start(m_pcm_playback);
+
+	if (length == frames) // Sometimes the fragments are "odd" in alsa
+		return size;
+	else
+	        return snd_pcm_frames_to_bytes(m_pcm_playback, length);
+}
+
+void AudioIOALSA::notifyIO(int fd, int type)
+{
+        int todo = 0;
+
+        // Translate from iomanager-types to poll-types,
+        // inorder to fake a snd_pcm_poll_descriptors_revents call.
+	if(m_pcm_playback) {
+	    for(int i=0; i < audio_write_pds.nfds; i++) {
+	        if(fd == audio_write_pds.pfds[i].fd) {
+                    audio_write_pds.pfds[i].revents = iomanager2poll(type);
+                    todo |= AudioSubSystem::ioWrite;
+                }
+            }
+            if (todo & AudioSubSystem::ioWrite) {
+                unsigned short revents;
+                snd_pcm_poll_descriptors_revents(m_pcm_playback,
+                                                 audio_write_pds.pfds,
+                                                 audio_write_pds.nfds,
+                                                 &revents);
+                if (! (revents & POLLOUT)) todo &= ~AudioSubSystem::ioWrite;
+            }
+	}
+	if(m_pcm_capture) {
+	    for(int i=0; i < audio_read_pds.nfds; i++) {
+	        if(fd == audio_read_pds.pfds[i].fd) {
+                    audio_read_pds.pfds[i].revents = iomanager2poll(type);
+                    todo |= AudioSubSystem::ioRead;
+                }
+            }
+            if (todo & AudioSubSystem::ioRead) {
+                unsigned short revents;
+                snd_pcm_poll_descriptors_revents(m_pcm_capture,
+                                                 audio_read_pds.pfds,
+                                                 audio_read_pds.nfds,
+                                                 &revents);
+                if (! (revents & POLLIN)) todo &= ~AudioSubSystem::ioRead;
+            }
+	}
+
+        if (type & IOType::except) todo |= AudioSubSystem::ioExcept;
+
+        if (todo != 0) AudioSubSystem::the()->handleIO(todo);
+}
+
+int AudioIOALSA::setPcmParams(snd_pcm_t *pcm)
+{
+	int &_samplingRate = param(samplingRate);
+	int &_channels = param(channels);
+	int &_fragmentSize = param(fragmentSize);
+	int &_fragmentCount = param(fragmentCount);
+	string& _error = paramStr(lastError);
+
+	snd_pcm_hw_params_t *hw;
+	snd_pcm_hw_params_alloca(&hw);
+	snd_pcm_hw_params_any(pcm, hw);
+
+	if (snd_pcm_hw_params_set_access(pcm, hw, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
+		_error = "Unable to set interleaved!";
+		return 1;
+	}
+	if (m_format == SND_PCM_FORMAT_UNKNOWN) {
+		// test the available formats
+		// try 16bit first, then fall back to 8bit
+		if (! snd_pcm_hw_params_test_format(pcm, hw, SND_PCM_FORMAT_S16_LE))
+			m_format = SND_PCM_FORMAT_S16_LE;
+		else if (! snd_pcm_hw_params_test_format(pcm, hw, SND_PCM_FORMAT_S16_BE))
+			m_format = SND_PCM_FORMAT_S16_BE;
+		else if (! snd_pcm_hw_params_test_format(pcm, hw, SND_PCM_FORMAT_U8))
+			m_format = SND_PCM_FORMAT_U8;
+                else
+                        m_format = SND_PCM_FORMAT_UNKNOWN;
+	}
+	if (snd_pcm_hw_params_set_format(pcm, hw, m_format) < 0) {
+		_error = "Unable to set format!";
+		return 1;
+	}
+
+	unsigned int rate = snd_pcm_hw_params_set_rate_near(pcm, hw, _samplingRate, 0);
+	const unsigned int tolerance = _samplingRate/10+1000;
+	if (abs((int)rate - (int)_samplingRate) > (int)tolerance) {
+		_error = "Can't set requested sampling rate!";
+		char details[80];
+		sprintf(details," (requested rate %d, got rate %d)",
+			_samplingRate, rate);
+		_error += details;
+		return 1;
+  	}
+	_samplingRate = rate;
+
+	if (snd_pcm_hw_params_set_channels(pcm, hw, _channels) < 0) {
+		_error = "Unable to set channels!";
+		return 1;
+	}
+
+	m_period_size = _fragmentSize;
+	if (m_format != SND_PCM_FORMAT_U8)
+		m_period_size <<= 1;
+	if (_channels > 1)
+	m_period_size /= _channels;
+	if ((m_period_size = snd_pcm_hw_params_set_period_size_near(pcm, hw, m_period_size, 0)) < 0) {
+		_error = "Unable to set period size!";
+		return 1;
+	}
+	m_periods = _fragmentCount;
+        if ((m_periods = snd_pcm_hw_params_set_periods_near(pcm, hw, m_periods, 0)) < 0) {
+		_error = "Unable to set periods!";
+		return 1;
+	}
+
+	if (snd_pcm_hw_params(pcm, hw) < 0) {
+		_error = "Unable to set hw params!";
+		return 1;
+	}
+
+	_fragmentSize = m_period_size;
+        _fragmentCount = m_periods;
+	if (m_format != SND_PCM_FORMAT_U8)
+		_fragmentSize >>= 1;
+	if (_channels > 1)
+		_fragmentSize *= _channels;
+
+	return 0; // ok, we're ready..
+}
+
+#endif /* HAVE_LIBASOUND2 */
diff --git a/flow/audioiocsl.cc b/flow/audioiocsl.cc
new file mode 100644
index 0000000..9a9b44e
--- /dev/null
+++ b/flow/audioiocsl.cc
@@ -0,0 +1,640 @@
+    /*
+
+    Copyright (C) 2000-2002 Stefan Westerfeld
+                            stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+ * only compile 'csl' AudioIO class if libcsl is present
+ */
+#ifdef HAVE_LIBCSL
+#include <csl/csl.h>
+
+/* g_newa */
+#include <gsl/gsldefs.h>
+
+#include <vector>
+
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "debug.h"
+#include "dispatcher.h"
+#include "iomanager.h"
+
+namespace Arts {
+
+class AudioIOCSL : public AudioIO,
+				   public IONotify
+{
+protected:
+	CslPcmStream *inputStream, *outputStream;
+	CslDriver *cslDriver;
+	int requestedFragmentSize;
+	int requestedFragmentCount;
+	const char *cslDriverName;
+
+	std::vector<CslPollFD> cslFds, cslOldFds;
+	int csl2iomanager(int cslTypes);
+	void updateFds();
+
+	void notifyIO(int fd, int types);
+	static void handleRead(void *user_data, CslPcmStream *stream);
+	static void handleWrite(void *user_data, CslPcmStream *stream);
+
+public:
+	AudioIOCSL(const char *driverName = 0);
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIOCSL,"csl","Common Sound Layer");
+
+class AudioIOCSLFactory : public AudioIOFactory {
+protected:
+	const char *driverName;
+	std::string _name;
+	std::string _fullName;
+
+public:
+	AudioIOCSLFactory(const char *driverName)
+		: driverName(driverName)
+	{
+		_name = "csl-";
+		_name += driverName;
+
+		_fullName = "Common Sound Layer (";
+		_fullName += driverName;
+		_fullName += ")";
+	}
+	virtual ~AudioIOCSLFactory()
+	{
+	}
+	AudioIO *createAudioIO() { return new AudioIOCSL(driverName); }
+	virtual const char *name() { return _name.c_str(); }
+	virtual const char *fullName() { return _fullName.c_str(); }
+};
+
+static class AudioIOCSLInit {
+protected:
+	std::list<AudioIOCSLFactory *> factories;
+
+public:
+    AudioIOCSLInit()
+    {
+		unsigned int i,n;
+		const char **drivers = csl_list_drivers(&n);
+
+		for(i = 0; i < n; i++)
+			factories.push_back(new AudioIOCSLFactory(drivers[i]));
+    }
+	~AudioIOCSLInit()
+	{
+		std::list<AudioIOCSLFactory *>::iterator i;
+		for(i = factories.begin(); i != factories.end(); i++)
+			delete (*i);
+
+		factories.clear();
+	}
+} aci;
+
+};
+
+using namespace std;
+using namespace Arts;
+
+AudioIOCSL::AudioIOCSL(const char *driverName)
+	: cslDriverName(driverName)
+{
+	/*
+	 * default parameters
+	 */
+	param(samplingRate) = 44100;
+	paramStr(deviceName) = "todo";
+	requestedFragmentSize = param(fragmentSize) = 1024;
+	requestedFragmentCount = param(fragmentCount) = 7;
+	param(channels) = 2;
+	param(direction) = 2;
+
+#ifdef WORDS_BIGENDIAN
+	param(format) = 17;
+#else
+	param(format) = 16;
+#endif
+}
+
+bool AudioIOCSL::open()
+{
+	string& errorMsg = paramStr(lastError);
+	string& _deviceName = paramStr(deviceName);
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+	int fmt = 0;
+	char *env = 0;
+
+	if(cslDriverName && strcmp(cslDriverName, "arts") == 0)
+		env = arts_strdup_printf("ARTS_SERVER=%s",_deviceName.c_str());
+
+	if(env)
+	{
+		putenv(env);
+		arts_debug("AudioIOCsl: set %s\n",env);
+	}
+
+	CslErrorType error;
+	error = csl_driver_init(cslDriverName, &cslDriver);    /* choose backend */
+
+	if(env)
+	{
+		putenv("ARTS_SERVER");
+		free(env);
+	}
+
+    if (error)
+	{
+    	errorMsg = "unable to initialize CSL driver: ";
+		errorMsg += csl_strerror(error);
+		return false;
+	}
+
+	if(_format == 8)
+		fmt = CSL_PCM_FORMAT_U8;
+	else if(_format == 16)
+		fmt = CSL_PCM_FORMAT_S16_LE;
+	else if(_format == 17)
+		fmt = CSL_PCM_FORMAT_S16_BE;
+
+	inputStream = outputStream = 0;
+	if(param(direction) & directionRead)
+	{
+   	    /* open PCM output stream */
+        error = csl_pcm_open_output(cslDriver,
+                                    "artsd output",
+                                    _samplingRate,
+									_channels,
+									fmt, &inputStream);
+		if (error)
+		{
+			errorMsg = "failed to open CSL input stream: ";
+			errorMsg += csl_strerror(error);
+			return false;
+		}
+		csl_pcm_set_callback(inputStream, handleRead, 0, 0);
+	}
+	if(param(direction) & directionWrite)
+	{
+	    /* open PCM output stream */
+        error = csl_pcm_open_output(cslDriver,
+                                    "artsd output",
+                                    _samplingRate,
+									_channels,
+									fmt, &outputStream);
+		if (error)
+		{
+			close();
+
+			errorMsg = "failed to open CSL output stream: ";
+			errorMsg += csl_strerror(error);
+			return false;
+		}
+		csl_pcm_set_callback(outputStream, handleWrite, 0, 0);
+	}
+#if 0
+	if (_format && (ossBits(gotFormat) != ossBits(requestedFormat)))
+	{  
+		char details[80];
+		sprintf(details," (_format = %d, asked driver to give %d, got %d)",
+			_format, requestedFormat, gotFormat);
+
+		_error = "Can't set playback format";
+		_error += details;
+
+		close();
+		return false;
+	}
+
+	if(gotFormat == AFMT_U8)
+		_format = 8;
+	else if(gotFormat == AFMT_S16_LE)
+		_format = 16;
+	else if(gotFormat == AFMT_S16_BE)
+		_format = 17;
+	else
+	{
+		char details[80];
+		sprintf(details," (_format = %d, asked driver to give %d, got %d)",
+			_format, requestedFormat, gotFormat);
+
+		_error = "unknown format given by driver";
+		_error += details;
+
+		close();
+		return false;
+	}
+
+
+	int stereo=-1;     /* 0=mono, 1=stereo */
+
+	if(_channels == 1)
+	{
+		stereo = 0;
+	}
+	if(_channels == 2)
+	{
+		stereo = 1;
+	}
+
+	if(stereo == -1)
+	{
+		_error = "internal error; set channels to 1 (mono) or 2 (stereo)";
+
+		close();
+		return false;
+	}
+
+	int requeststereo = stereo;
+
+	if (ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo)==-1)
+	{
+		_error = "SNDCTL_DSP_STEREO failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+	}
+
+	if (requeststereo != stereo)
+	{
+		_error = "audio device doesn't support number of requested channels";
+
+		close();
+		return false;
+	}
+
+	int speed = _samplingRate;
+
+	if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &speed)==-1)  
+	{
+		_error = "SNDCTL_DSP_SPEED failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+	}  
+
+    /*
+	 * Some soundcards seem to be able to only supply "nearly" the requested
+	 * sampling rate, especially PAS 16 cards seem to quite radical supplying
+	 * something different than the requested sampling rate ;)
+	 *
+	 * So we have a quite large tolerance here (when requesting 44100 Hz, it
+	 * will accept anything between 38690 Hz and 49510 Hz). Most parts of the
+	 * aRts code will do resampling where appropriate, so it shouldn't affect
+	 * sound quality.
+	 */
+    int tolerance = _samplingRate/10+1000;
+
+	if (abs(speed-_samplingRate) > tolerance)
+	{  
+		_error = "can't set requested samplingrate";
+
+		char details[80];
+		sprintf(details," (requested rate %d, got rate %d)",
+			_samplingRate, speed);
+		_error += details;
+
+		close();
+		return false;
+	} 
+	_samplingRate = speed;
+
+	/*
+	 * set the fragment settings to what the user requested
+	 */
+	
+	_fragmentSize = requestedFragmentSize;
+	_fragmentCount = requestedFragmentCount;
+
+	/*
+	 * lower 16 bits are the fragment size (as 2^S)
+	 * higher 16 bits are the number of fragments
+	 */
+	int frag_arg = 0;
+
+	int size = _fragmentSize;
+	while(size > 1) { size /= 2; frag_arg++; }
+	frag_arg += (_fragmentCount << 16);
+	if(ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_arg) == -1)
+	{
+		char buffer[1024];
+		_error = "can't set requested fragments settings";
+		sprintf(buffer,"size%d:count%d\n",_fragmentSize,_fragmentCount);
+		close();
+		return false;
+	}
+
+	/*
+	 * now see what we really got as cards aren't required to supply what
+	 * we asked for
+	 */
+	audio_buf_info info;
+	if(ioctl(audio_fd,SNDCTL_DSP_GETOSPACE, &info) == -1)
+	{
+		_error = "can't retrieve fragment settings";
+		close();
+		return false;
+	}
+
+	// update fragment settings with what we got
+	_fragmentSize = info.fragsize;
+	_fragmentCount = info.fragstotal;
+
+	artsdebug("buffering: %d fragments with %d bytes "
+		"(audio latency is %1.1f ms)", _fragmentCount, _fragmentSize,
+		(float)(_fragmentSize*_fragmentCount) /
+		(float)(2.0 * _samplingRate * _channels)*1000.0);
+
+	/*
+	 * Workaround for broken kernel drivers: usually filling up the audio
+	 * buffer is _only_ required if _fullDuplex is true. However, there
+	 * are kernel drivers around (especially everything related to ES1370/1371)
+	 * which will not trigger select()ing the file descriptor unless we have
+	 * written something first.
+	 */
+	char *zbuffer = (char *)calloc(sizeof(char), _fragmentSize);
+	if(_format == 8)
+		for(int zpos = 0; zpos < _fragmentSize; zpos++)
+			zbuffer[zpos] |= 0x80;
+	
+	for(int fill = 0; fill < _fragmentCount; fill++)
+	{
+		int len = ::write(audio_fd,zbuffer,_fragmentSize);
+		if(len != _fragmentSize)
+		{
+			arts_debug("AudioIOCSL: failed prefilling audio buffer (might cause synchronization problems in conjunction with full duplex)");
+			fill = _fragmentCount+1;
+		}
+	}
+	free(zbuffer);
+
+	/*
+	 * Triggering - the original aRts code did this for full duplex:
+	 *
+	 *  - stop audio i/o using SETTRIGGER(~(PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT))
+	 *  - fill buffer (see zbuffer code two lines above)
+	 *  - start audio i/o using SETTRIGGER(PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT)
+	 *
+	 * this should guarantee synchronous start of input/output. Today, it
+	 * seems there are too many broken drivers around for this.
+	 */
+
+	if(device_caps & DSP_CAP_TRIGGER)
+	{
+		int enable_bits = 0;
+
+		if(param(direction) & 1) enable_bits |= PCM_ENABLE_INPUT;
+		if(param(direction) & 2) enable_bits |= PCM_ENABLE_OUTPUT;
+
+		if(ioctl(audio_fd,SNDCTL_DSP_SETTRIGGER, &enable_bits) == -1)
+		{
+			_error = "can't start sound i/o";
+
+			close();
+			return false;
+		}
+	}
+#endif
+	updateFds();
+	return true;
+}
+
+void AudioIOCSL::close()
+{
+	if(inputStream)
+	{
+		csl_pcm_close(inputStream);
+		inputStream = 0;
+	}
+	if(outputStream)
+	{
+		csl_pcm_close(outputStream);
+		outputStream = 0;
+	}
+	updateFds();
+}
+
+void AudioIOCSL::setParam(AudioParam p, int& value)
+{
+	switch(p)
+	{
+		case fragmentSize:
+				param(p) = requestedFragmentSize = value;
+			break;
+		case fragmentCount:
+				param(p) = requestedFragmentCount = value;
+			break;
+		default:
+				param(p) = value;
+			break;
+	}
+}
+
+int AudioIOCSL::getParam(AudioParam p)
+{
+    CslErrorType error;
+	CslPcmStatus status;
+
+	switch(p)
+	{
+		case canRead:
+				error = csl_pcm_get_status (inputStream, &status);
+				if (error) /* FIXME */
+					arts_fatal("unable to obtain csl stream status: %s",
+							   csl_strerror (error));
+
+				updateFds();
+				return status.n_bytes_available;
+			break;
+
+		case canWrite:
+				error = csl_pcm_get_status(outputStream, &status);
+				if (error) /* FIXME */
+					arts_fatal("unable to obtain csl stream status: %s",
+							   csl_strerror (error));
+
+				updateFds();
+				return status.n_bytes_available;
+			break;
+
+		case autoDetect:
+				/* CSL is pretty experimental currently */
+				return 1;	
+			break;
+
+		default:
+				return param(p);
+			break;
+	}
+}
+
+int AudioIOCSL::read(void *buffer, int size)
+{
+	arts_assert(inputStream != 0);
+
+	int result = csl_pcm_read(inputStream, size, buffer);
+	updateFds();
+
+	return result;
+}
+
+void AudioIOCSL::handleRead(void *, CslPcmStream *)
+{
+	AudioSubSystem::the()->handleIO(AudioSubSystem::ioRead);
+}
+
+int AudioIOCSL::write(void *buffer, int size)
+{
+	arts_assert(outputStream != 0);
+
+	int result = csl_pcm_write(outputStream, size, buffer);
+	updateFds();
+
+	return result;
+}
+
+void AudioIOCSL::handleWrite(void *, CslPcmStream *)
+{
+	AudioSubSystem::the()->handleIO(AudioSubSystem::ioWrite);
+}
+
+/* mainloop integration: make CSL callbacks work inside the aRts mainloop */
+
+int AudioIOCSL::csl2iomanager(int cslTypes)
+{
+	/* FIXME: doublecheck this list */
+	int types = 0;
+
+	if(cslTypes & CSL_POLLIN)
+		types |= IOType::read;
+	if(cslTypes & CSL_POLLOUT)
+		types |= IOType::write;
+	if(cslTypes & CSL_POLLERR)
+		types |= IOType::except;
+
+	return types;
+}
+
+void AudioIOCSL::updateFds()
+{
+	unsigned int n_fds = csl_poll_count_fds(cslDriver);
+	CslPollFD *newFds = g_newa(CslPollFD, n_fds);
+
+	unsigned int have_fds = csl_poll_get_fds(cslDriver, n_fds, newFds);
+	arts_assert(have_fds == n_fds);
+
+	cslFds.clear();
+
+	unsigned int i;
+	for(i = 0; i < have_fds; i++)
+		cslFds.push_back(newFds[i]);
+
+	/* FIXME: if csl provided a flag for this, we could save some work here */
+	bool fdsChanged;
+	if(cslFds.size() == cslOldFds.size())
+	{
+		fdsChanged = false;
+		for(i = 0; i < have_fds; i++)
+		{
+			if(cslFds[i].events != cslOldFds[i].events)
+				fdsChanged = true;
+			if(cslFds[i].fd != cslOldFds[i].fd)
+				fdsChanged = true;
+		}
+	}
+	else
+	{
+		fdsChanged = true;
+	}
+	if(!fdsChanged)
+		return;
+
+	vector<CslPollFD>::iterator ci;
+
+	/* remove old watches */
+	/*
+	 * UGLY! due to broken API, we can only remove all watches here, and not
+	 * do anything selectively - its not a problem for the code here, but it
+	 * might be a problem elsewhere. Unfortunately, it can't be fixed without
+	 * breaking BC.
+	 */
+	Dispatcher::the()->ioManager()->remove(this, IOType::all);
+	arts_debug("AudioIOCSL::updateFds(): removing watches");
+
+	/* add new watches */
+	for(ci = cslFds.begin(); ci < cslFds.end(); ci++)
+	{
+		int types = csl2iomanager(ci->events);
+		if(types)
+		{
+			Dispatcher::the()->ioManager()->watchFD(ci->fd, types, this);
+			arts_debug("AudioIOCSL::updateFds(): adding watch on %d", ci->fd);
+		}
+	}
+
+	cslOldFds = cslFds;
+}
+
+void AudioIOCSL::notifyIO(int fd, int type)
+{
+	vector<CslPollFD>::iterator fi;
+
+	for(fi = cslFds.begin(); fi != cslFds.end(); fi++)
+	{
+		if(fi->fd == fd)
+		{
+			int ftype = csl2iomanager(fi->events);
+			fi->revents = 0;
+
+			if(type & ftype & IOType::read)
+				fi->revents |= CSL_POLLIN;
+			if(type & ftype & IOType::write)
+				fi->revents |= CSL_POLLOUT;
+			if(type & ftype & IOType::except)
+				fi->revents |= CSL_POLLERR;
+
+			if(fi->revents)
+				csl_poll_handle_fds(cslDriver, 1, &(*fi));
+		}
+	}
+	updateFds();
+}
+
+#endif
diff --git a/flow/audioioesd.cc b/flow/audioioesd.cc
new file mode 100644
index 0000000..a3fa4b5
--- /dev/null
+++ b/flow/audioioesd.cc
@@ -0,0 +1,231 @@
+    /*
+
+    Copyright (C) 2001 Jochen Hoenicke
+                       jochen@gnu.org
+
+    Copyright (C) 2003 Ian Chiew
+                       ian@snork.net
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+ * only compile esound AudioIO class if libesd was detected during
+ * configure
+ */
+#ifdef HAVE_LIBESD
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "iomanager.h"
+#include "dispatcher.h"
+
+#include <esd.h>
+
+#ifdef __BIG_ENDIAN__
+#define _format_bits 17
+#else
+#define _format_bits 16
+#endif
+
+namespace Arts {
+
+class AudioIOESD : public AudioIO, public IONotify {
+protected:
+	int server_fd, read_fd, write_fd;
+
+public:
+	AudioIOESD();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+	void notifyIO(int fd, int type);
+
+	bool open();
+	void close();
+	void run();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIOESD,"esd","Enlightened Sound Daemon");
+}
+
+using namespace std;
+using namespace Arts;
+
+AudioIOESD::AudioIOESD()
+{
+	/*
+	 * default parameters
+	 */
+	param(samplingRate) = 44100;
+	paramStr(deviceName) = "null";
+	param(fragmentSize) = 1024;
+	param(fragmentCount) = 7;
+	param(format) = _format_bits;
+	param(channels) = 2;
+	param(direction) = 2;
+
+	server_fd = -1;
+	read_fd = -1;
+	write_fd = -1;
+}
+
+bool AudioIOESD::open()
+{
+	int& _channels = param(channels);
+	int& _direction = param(direction);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+	string& _error = paramStr(lastError);
+
+	if ((server_fd = esd_open_sound(NULL)) == -1)
+	{
+		_error = "Couldn't connect to server";
+		return false;
+	}
+
+	esd_server_info_t *server_info = esd_get_server_info(server_fd);
+
+	if (server_info == NULL)
+	{
+		_error = "Unable to query EsounD server";
+		return false;
+	}
+	
+	esd_format_t server_format = server_info->format;
+
+	_samplingRate = server_info->rate;
+	_channels     = (server_format & ESD_STEREO) ? 2            : 1;
+	_format       = (server_format & ESD_BITS16) ? _format_bits : 8;
+
+	esd_free_server_info(server_info);
+	
+	if (_direction & directionRead)
+	{
+		read_fd = esd_record_stream(server_format, _samplingRate,
+					    NULL, "aRts");
+		if (read_fd == -1)
+		{
+			_error = "Couldn't create read uflow";
+			return false;
+		}
+	}
+
+	if (_direction & directionWrite)
+	{
+		write_fd = esd_play_stream(server_format, _samplingRate,
+					   NULL, "aRts");
+		if (write_fd == -1)
+		{
+			_error = "Couldn't create write flow";
+			return false;
+		}
+	}
+
+	return true;
+}
+
+void AudioIOESD::notifyIO(int, int)
+{
+}
+
+void AudioIOESD::close()
+{
+	if (write_fd != -1) 
+		esd_close(write_fd);
+
+	if (read_fd != -1)
+		esd_close(read_fd);
+
+	if (server_fd != -1)
+		esd_close(server_fd);
+}
+
+void AudioIOESD::setParam(AudioParam p, int& value)
+{
+	switch(p)
+	{
+	case channels:
+	case format:
+	case direction:
+	case samplingRate:
+		param(p) = value;
+		close();
+		open();
+		return;
+
+	default:
+		param(p) = value;
+		return;
+	}
+}
+
+int AudioIOESD::getParam(AudioParam p)
+{
+	switch(p)
+	{
+	case selectReadFD:
+		return read_fd;
+
+	case selectWriteFD:
+		return write_fd;
+
+	case canRead:
+		return ESD_BUF_SIZE;
+
+	case canWrite:
+		return ESD_BUF_SIZE;
+
+		// ESD handles are actually socket descriptors, and I know not
+		// of any portable way to peek at the socket's send or receive
+		// buffers.
+
+	default:
+		return param(p);
+	}
+}
+
+int AudioIOESD::read(void *buffer, int size)
+{
+	return ::read(read_fd, buffer, size);
+}
+
+int AudioIOESD::write(void *buffer, int size)
+{
+	return ::write(write_fd, buffer, size);
+}
+
+#endif
diff --git a/flow/audioiojack.cc b/flow/audioiojack.cc
new file mode 100644
index 0000000..787ac03
--- /dev/null
+++ b/flow/audioiojack.cc
@@ -0,0 +1,346 @@
+/*
+    Copyright (C) 2004 Matthias Kretz <kretz@kde.org>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License version 2 as published by the Free Software Foundation.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_LIBJACK
+
+#include <jack/jack.h>
+#include <jack/ringbuffer.h>
+
+#include "debug.h"
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "iomanager.h"
+#include "dispatcher.h"
+
+#ifndef MIN
+#define MIN(a,b)        ((a) < (b) ? (a) : (b))
+#endif
+
+#undef DEBUG_WAVEFORM
+#ifdef DEBUG_WAVEFORM
+#include <fstream>
+#endif
+
+#include <cstdlib>
+#include <cstring>
+
+namespace Arts {
+
+class AudioIOJack : public AudioIO, public TimeNotify {
+private:
+#ifdef DEBUG_WAVEFORM
+	std::ofstream plotfile;
+#endif
+	char * processBuffer;
+	size_t buffersize;
+
+protected:
+	jack_client_t *jack;
+	jack_port_t *outleft, *outright;
+	jack_port_t *inleft, *inright;
+	jack_ringbuffer_t *olb, *orb, *ilb, *irb;
+
+public:
+	AudioIOJack();
+
+	void notifyTime();
+
+	void setParam( AudioParam p, int & val );
+	int getParam(AudioParam param);
+
+	static int jackCallback( jack_nframes_t, void * );
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIOJack,"jack","Jack Audio Connection Kit");
+}
+
+using namespace std;
+using namespace Arts;
+
+AudioIOJack::AudioIOJack()
+	:
+#ifdef DEBUG_WAVEFORM
+	plotfile( "/dev/shm/audioiojack.plot" ),
+#endif
+	jack( 0 )
+	, outleft( 0 )
+	, outright( 0 )
+	, inleft( 0 )
+	, inright( 0 )
+{
+	/*
+	 * default parameters
+	 */
+	param( samplingRate ) = 44100;
+	paramStr( deviceName ) = "jack";
+	param( fragmentSize ) = 512;
+	param( fragmentCount ) = 2;
+	param( channels ) = 2;
+	param( direction ) = 2;
+	param( format ) = 32;
+}
+
+bool AudioIOJack::open()
+{
+	string& _error = paramStr( lastError );
+	jack = jack_client_new( "artsd" );
+	if( jack == 0 )
+	{
+		_error = "Couldn't connect to jackd";
+		return false;
+	}
+
+	int& _sampleRate = param(samplingRate);
+	_sampleRate = jack_get_sample_rate( jack );
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+
+	/*
+	 * don't allow unreasonable large fragmentSize/Count combinations,
+	 * because "real" hardware also doesn't
+	 */
+
+	if(_fragmentSize > 1024*8) _fragmentSize = 1024*8;
+
+	while(_fragmentSize * _fragmentCount > 1024*128)
+		_fragmentCount--;
+
+	jack_set_process_callback( jack, Arts::AudioIOJack::jackCallback, this );
+
+	if( param( direction ) & directionWrite )
+	{
+		outleft = jack_port_register( jack, "out_1",
+				JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 );
+		outright = jack_port_register( jack, "out_2",
+				JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 );
+		olb = jack_ringbuffer_create(
+				sizeof( jack_default_audio_sample_t ) *
+				_fragmentSize * _fragmentCount );
+		orb = jack_ringbuffer_create(
+				sizeof( jack_default_audio_sample_t ) *
+				_fragmentSize * _fragmentCount );
+	}
+	if( param( direction ) & directionRead )
+	{
+		inleft = jack_port_register( jack, "in_1",
+				JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 );
+		inright = jack_port_register( jack, "in_2",
+				JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 );
+		ilb = jack_ringbuffer_create(
+				sizeof( jack_default_audio_sample_t ) *
+				1024 * 64 );
+		irb = jack_ringbuffer_create(
+				sizeof( jack_default_audio_sample_t ) *
+				1024 * 64 );
+	}
+
+	if( jack_activate( jack ) )
+	{
+		_error = "Activating as jack client failed.";
+		return false;
+	}
+
+	const char **ports;
+	if( param( direction ) & directionRead )
+	{
+		ports = jack_get_ports( jack, 0, 0, JackPortIsPhysical
+				| JackPortIsOutput );
+		if( ports == 0 )
+		{
+			arts_warning( "Cannot find any capture ports to"
+					" connect to. You need to manually connect"
+					" the capture ports in jack" );
+		}
+		else
+		{
+			if( ports[ 0 ] != 0 )
+				jack_connect( jack, ports[ 0 ],
+						jack_port_name( inleft ) );
+			if( ports[ 1 ] != 0 )
+				jack_connect( jack, ports[ 1 ],
+						jack_port_name( inright ) );
+			free( ports );
+		}
+	}
+	if( param( direction ) & directionWrite )
+	{
+		ports = jack_get_ports( jack, 0, 0, JackPortIsPhysical
+				| JackPortIsInput );
+		if( ports == 0 )
+		{
+			arts_warning( "Cannot find any playback ports to"
+					" connect to. You need to manually connect"
+					" the playback ports in jack" );
+		}
+		else
+		{
+			if( ports[ 0 ] != 0 )
+				jack_connect( jack, jack_port_name( outleft ),
+						ports[ 0 ] );
+			if( ports[ 1 ] != 0 )
+				jack_connect( jack, jack_port_name( outright ),
+						ports[ 1 ] );
+			free( ports );
+		}
+	}
+
+	// Install the timer
+	Dispatcher::the()->ioManager()->addTimer(10, this);
+
+	return true;
+}
+
+void AudioIOJack::close()
+{
+	jack_client_close( jack );
+    Dispatcher::the()->ioManager()->removeTimer(this);
+}
+
+int AudioIOJack::jackCallback( jack_nframes_t nframes, void * args )
+{
+	AudioIOJack * that = static_cast<AudioIOJack*>( args );
+
+	that->buffersize = nframes * sizeof( jack_default_audio_sample_t );
+	if( that->outleft )
+	{
+		if( jack_ringbuffer_read_space( that->olb ) < that->buffersize )
+		{
+			that->processBuffer = static_cast<char *>(
+					jack_port_get_buffer( that->outleft, nframes ) );
+			memset( that->processBuffer, 0, that->buffersize );
+			that->processBuffer = static_cast<char *>(
+					jack_port_get_buffer( that->outright, nframes ) );
+			memset( that->processBuffer, 0, that->buffersize );
+		}
+		else
+		{
+			that->processBuffer = static_cast<char *>(
+					jack_port_get_buffer( that->outleft, nframes ) );
+			jack_ringbuffer_read( that->olb, that->processBuffer, that->buffersize );
+			that->processBuffer = static_cast<char *>(
+					jack_port_get_buffer( that->outright, nframes ) );
+			jack_ringbuffer_read( that->orb, that->processBuffer, that->buffersize );
+		}
+	}
+	if( that->inleft )
+	{
+		that->processBuffer = static_cast<char *>(
+				jack_port_get_buffer( that->inleft, nframes ) );
+		jack_ringbuffer_write( that->ilb, that->processBuffer, that->buffersize );
+		that->processBuffer = static_cast<char *>(
+				jack_port_get_buffer( that->inright, nframes ) );
+		jack_ringbuffer_write( that->irb, that->processBuffer, that->buffersize );
+	}
+	return 0;
+}
+
+void AudioIOJack::setParam( AudioParam p, int& val )
+{
+	// don't change the format - jack only supports 32 bit float
+	if( p == format )
+		return;
+	AudioIO::setParam( p, val );
+}
+
+int AudioIOJack::getParam(AudioParam p)
+{
+	switch(p)
+	{
+		case canRead:
+			return MIN( jack_ringbuffer_read_space( ilb ), jack_ringbuffer_read_space( irb ) ) * param( channels );
+		case canWrite:
+			return MIN( jack_ringbuffer_write_space( olb ), jack_ringbuffer_write_space( orb ) ) * param( channels );
+		default:
+			return AudioIO::getParam( p );
+	}
+}
+
+int AudioIOJack::read(void *buffer, int size)
+{
+	float * floatbuffer = static_cast<float *>( buffer );
+	if( param( channels ) == 2 )
+	{
+		float * end = ( float * )( static_cast<char *>( buffer ) + size );
+		while( floatbuffer < end )
+		{
+			jack_ringbuffer_read( ilb, ( char* )( floatbuffer++ ), sizeof( float ) );
+#ifdef DEBUG_WAVEFORM
+			plotfile << *( floatbuffer - 1 ) << "\n";
+#endif
+			jack_ringbuffer_read( irb, ( char* )( floatbuffer++ ), sizeof( float ) );
+		}
+	}
+	else if( param( channels ) == 1 )
+	{
+		jack_ringbuffer_read( ilb, ( char* )( floatbuffer ), size );
+	}
+	return size;
+}
+
+int AudioIOJack::write(void *buffer, int size)
+{
+	float * floatbuffer = static_cast<float *>( buffer );
+	if( param( channels ) == 2 )
+	{
+		float * end = ( float * )( static_cast<char *>( buffer ) + size );
+		while( floatbuffer < end )
+		{
+			jack_ringbuffer_write( olb, ( char* )( floatbuffer++ ), sizeof( float ) );
+			jack_ringbuffer_write( orb, ( char* )( floatbuffer++ ), sizeof( float ) );
+		}
+	}
+	else if( param( channels ) == 1 )
+	{
+		jack_ringbuffer_write( olb, ( char* )( floatbuffer ), size );
+	}
+	return size;
+}
+
+void AudioIOJack::notifyTime()
+{
+    int& _direction = param(direction);
+    int& _fragmentSize = param(fragmentSize);
+
+	for( ;; )
+	{
+		int todo = 0;
+		if( ( _direction & directionRead ) && ( getParam( canRead ) >= _fragmentSize ) )
+			todo |= AudioSubSystem::ioRead;
+
+		if( ( _direction & directionWrite ) && ( getParam( canWrite ) >= _fragmentSize ) )
+			todo |= AudioSubSystem::ioWrite;
+
+		if( ! todo )
+			return;
+
+		AudioSubSystem::the()->handleIO( todo );
+	}
+}
+
+#endif
+// vim: sw=4 ts=4
diff --git a/flow/audioiolibaudioio.cc b/flow/audioiolibaudioio.cc
new file mode 100644
index 0000000..e7c545e
--- /dev/null
+++ b/flow/audioiolibaudioio.cc
@@ -0,0 +1,236 @@
+    /*
+
+    Copyright (C) 2001 Robert Lunnon
+                       bob@yarrabee.net.au
+    Copyright (C) 2001 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+ * only compile 'LibAudioIO' AudioIO class if libaudio was detected during
+ * configure
+ */
+#ifdef HAVE_LIBAUDIOIO
+
+#include <libaudioio.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>		// Needed on some systems.
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+
+#include "debug.h"
+#include "audioio.h"
+
+namespace Arts {
+
+class AudioIOLibAudioIO : public AudioIO {
+protected:
+	int audio_fd;
+	int requestedFragmentSize;
+	int requestedFragmentCount;
+	SampleSpec_t spec;
+
+public:
+	AudioIOLibAudioIO();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIOLibAudioIO,"libaudioio"," Portable Audio Library");
+};
+
+using namespace std;
+using namespace Arts;
+
+AudioIOLibAudioIO::AudioIOLibAudioIO()
+{
+	/*
+	 * default parameters
+	 */
+	param(samplingRate) = spec.rate=44100;
+	paramStr(deviceName) = "/dev/Audio";
+	requestedFragmentSize = param(fragmentSize) = 4096;
+	requestedFragmentCount  =spec.max_blocks= param(fragmentCount) = 7;
+	param(channels) = spec.channels=2;
+	param(direction) = 2;
+}
+
+bool AudioIOLibAudioIO::open()
+{
+	string& _error = paramStr(lastError);
+	string& _deviceName = paramStr(deviceName);
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+
+	int mode;
+	spec.channels=_channels;
+	spec.max_blocks= param(fragmentCount);
+	spec.rate= _samplingRate;
+	spec.encoding= ENCODE_PCM;
+	spec.precision=16 ;
+	spec.endian=ENDIAN_NATURAL;
+	spec.disable_threads=1;
+
+	if(param(direction) == 3)
+		mode = O_RDWR|O_NDELAY;
+	else if(param(direction) == 2)
+		mode = O_WRONLY|O_NDELAY;
+	else
+	{
+		_error = "invalid direction";
+		return false;
+	}
+
+	audio_fd = ::AudioIOOpenX( mode, &spec,&spec );
+	if(audio_fd == -1)
+	{
+		_error = "device ";
+		_error += _deviceName.c_str();
+		_error += " can't be opened (";
+		_error += strerror(errno);
+		_error += ")";
+		return false;
+	}
+
+
+	/*
+	 * since we use spec.endian=ENDIAN_NATURAL we'll have little endian audio
+	 * on little endian machines and big endian audio on big endian machines:
+	 */
+#ifdef WORDS_BIGENDIAN
+	_format = 17;
+#else
+	_format = 16;
+#endif
+
+	spec.channels=_channels;
+
+	spec.rate = _samplingRate;
+
+
+	_fragmentSize = requestedFragmentSize;
+	spec.max_blocks=_fragmentCount = requestedFragmentCount;
+
+
+	artsdebug("buffering: %d fragments with %d bytes "
+		"(audio latency is %1.1f ms)", _fragmentCount, _fragmentSize,
+		(float)(_fragmentSize*_fragmentCount) /
+		(float)(2.0 * _samplingRate * _channels)*1000.0);
+
+	return(true);
+}
+
+void AudioIOLibAudioIO::close()
+{
+	::AudioIOClose();
+}
+
+void AudioIOLibAudioIO::setParam(AudioParam p, int& value)
+{
+	switch(p)
+	{
+		case fragmentSize:
+				param(p) = requestedFragmentSize = value;
+			break;
+		case fragmentCount:
+				param(p) = requestedFragmentCount = value;
+			break;
+		default:
+				param(p) = value;
+			break;
+	}
+}
+
+int AudioIOLibAudioIO::getParam(AudioParam p)
+{
+	switch(p)
+	{
+		case canRead:
+				return AudioIOCheckRead();
+			break;
+
+		case canWrite:
+				return (AudioIOCheckWriteReady()) ? (16*1024) : 0;
+				// Assume if writable can write 16K
+				// Arts Really doesn't care
+			break;
+
+		case selectReadFD:
+				return (param(direction) & directionRead)?audio_fd:-1;
+			break;
+
+		case selectWriteFD:
+				return (param(direction) & directionWrite)?audio_fd:-1;
+			break;
+
+		case autoDetect:
+				/*
+				 * if there is a "native" aRts driver, we'll rather use this
+				 * than the generic libaudioio one, because the native one
+				 * is likely to be better optimized to the needs of aRts than
+				 * a generic driver, so keep the value small
+				 */
+				return 3;
+			break;
+
+		default:
+				return param(p);
+			break;
+	}
+}
+
+int AudioIOLibAudioIO::read(void *buffer, int size)
+{
+	arts_assert(audio_fd != 0);
+	return ::AudioIORead(buffer,size);
+}
+
+int AudioIOLibAudioIO::write(void *buffer, int size)
+{
+	arts_assert(audio_fd != 0);
+	return ::AudioIOWrite(buffer,size);
+}
+
+#endif
diff --git a/flow/audioiomas.cc b/flow/audioiomas.cc
new file mode 100644
index 0000000..e49fec2
--- /dev/null
+++ b/flow/audioiomas.cc
@@ -0,0 +1,619 @@
+    /*
+
+    Copyright (C) 2001-2003 Stefan Westerfeld
+                            stefan@space.twc.de
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/*
+ * Only compile this AudioIO class if we have MAS
+ */
+#ifdef HAVE_LIBMAS
+
+extern "C" {
+#include <mas/mas.h>
+#include <mas/mas_getset.h>
+#include <mas/mas_source.h>
+}
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+
+#include "debug.h"
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "iomanager.h"
+#include "dispatcher.h"
+
+namespace Arts {
+
+    class AudioIOMAS : public AudioIO, public TimeNotify {
+    protected:
+		mas_channel_t audio_channel;
+		mas_port_t    mix_sink;
+		mas_port_t    srate_source, srate_sink;
+		mas_port_t    audio_source, audio_sink;
+		mas_port_t    endian_sink, endian_source;
+		mas_port_t    sbuf_source, sbuf_sink;
+		mas_port_t    squant_sink, squant_source;
+		mas_port_t    open_source; /* (!) */
+		mas_device_t  endian;
+		mas_device_t  srate;
+		mas_device_t  squant;
+		mas_device_t  sbuf;
+		mas_data     *data;
+    	mas_package	  package;
+        int32         mas_error;
+
+		std::list<mas_channel_t>	allocated_channels;
+		std::list<mas_port_t>		allocated_ports;
+		std::list<mas_device_t>		allocated_devices;
+
+		double lastUpdate, bytesPerSec;
+		int  readBufferAvailable;
+		int  writeBufferAvailable;
+
+		double currentTime();
+		void updateBufferSizes();
+
+#ifdef WORDS_BIGENDIAN
+		static const int defaultFormat = 17;
+#else
+		static const int defaultFormat = 16;
+#endif
+		bool close_with_error(const std::string& text);
+    public:
+		AudioIOMAS();
+
+		// Timer callback
+		void notifyTime();
+
+		void setParam(AudioParam param, int& value);
+		int getParam(AudioParam param);
+
+		bool open();
+		void close();
+		int read(void *buffer, int size);
+		int write(void *buffer, int size);
+    };
+
+    REGISTER_AUDIO_IO(AudioIOMAS,"mas","MAS Audio Input/Output");
+
+};
+
+using namespace std;
+using namespace Arts;
+
+AudioIOMAS::AudioIOMAS()
+{
+    /*
+     * default parameters
+     */
+    param(samplingRate) = 44100;
+    paramStr(deviceName) = ""; // TODO
+    param(fragmentSize) = 4096;
+    param(fragmentCount) = 7;
+    param(channels) = 2;
+    param(direction) = 2;
+    param(format) = defaultFormat;
+}
+
+namespace {
+	int masInitCount = 0;
+}
+
+// Opens the audio device
+bool AudioIOMAS::open()
+{
+    string& _error = paramStr(lastError);
+    string& _deviceName = paramStr(deviceName);
+    int& _channels = param(channels);
+    int& _fragmentSize = param(fragmentSize);
+    int& _fragmentCount = param(fragmentCount);
+    int& _samplingRate = param(samplingRate);
+    int& _format = param(format);
+
+	/* FIXME: do we need to free what we allocate with mas_init() in close() */
+	if (!masInitCount)
+	{
+		mas_error = mas_init();
+
+		if (mas_error < 0)
+			return close_with_error("error connecting to MAS server");
+	}
+	masInitCount++;
+
+	if (param(direction) != 2)
+	{
+		_error = "unsupported direction (currently no full duplex support)";
+		return false;
+	}
+
+	/*
+	 * data path
+	 *
+	 * audio_sink
+	 * audio_channel: data_channel ("artsd")
+	 * audio_source
+	 *   |
+	 *   V
+	 * endian_sink
+	 * endian: instantiate_device ("endian")
+	 * open_source = endian_source
+	 *   |
+	 *   V
+	 * [squant_sink]
+	 * [squant]
+	 * [squant_source]
+	 *   |
+	 *   V
+	 * [srate_sink]
+	 * [srate]
+	 * [srate_source]
+	 *   |
+	 *   V
+	 * sbuf_sink
+	 * sbuf
+	 * sbuf_source
+	 *   |
+	 *   V
+	 * mix_sink: port ("default_mix_sink")
+	 */
+
+	// audio_channel, source & sink
+	mas_error = mas_make_data_channel("artsd", &audio_channel, &audio_source, &audio_sink);
+	if (mas_error < 0)
+		return close_with_error("error initializing MAS data channel");
+
+	allocated_channels.push_back(audio_channel);
+	allocated_ports.push_back(audio_source);
+	allocated_ports.push_back(audio_sink);
+
+	// endian, source & sink
+	mas_error = mas_asm_instantiate_device( "endian", 0, 0, &endian );
+	if ( mas_error < 0 )
+		return close_with_error("error initantiating MAS endian device");
+
+	allocated_devices.push_back(endian);
+
+	mas_error = mas_asm_get_port_by_name( endian, "sink", &endian_sink );
+	if ( mas_error < 0 )
+		return close_with_error("error getting MAS endian device sink port");
+
+	allocated_ports.push_back(endian_sink);
+
+	mas_error = mas_asm_get_port_by_name( endian, "source", &endian_source );
+	if ( mas_error < 0 )
+		return close_with_error("error getting MAS endian device source port");
+
+	allocated_ports.push_back(endian_source);
+
+	char ratestring[16], resolutionstring[16];
+	sprintf (ratestring, "%u", _samplingRate);
+	sprintf (resolutionstring, "%u", _format);
+
+	mas_data_characteristic* dc;
+
+    dc = (mas_data_characteristic *)MAS_NEW( dc );
+	masc_setup_dc( dc, 6 );
+	masc_append_dc_key_value( dc, "format", (_format==8) ? "ulinear":"linear" );
+
+	masc_append_dc_key_value( dc, "resolution", resolutionstring );
+	masc_append_dc_key_value( dc, "sampling rate", ratestring );
+	masc_append_dc_key_value( dc, "channels", "2" );
+	masc_append_dc_key_value( dc, "endian", "little" );
+
+    mas_error = mas_asm_connect_source_sink( audio_source, endian_sink, dc );
+	if ( mas_error < 0 )
+		return close_with_error("error connecting MAS net audio source to endian sink");
+
+    /* The next device is 'if needed' only. After the following if()
+       statement, open_source will contain the current unconnected
+       source in the path (will be either endian_source or
+       squant_source in this case)
+    */
+    open_source = endian_source;
+    
+    if ( _format != 16 )
+    {
+		arts_debug("MAS output: Sample resolution is not 16 bit/sample, instantiating squant device.");
+
+		// squant, source & sink
+        mas_error = mas_asm_instantiate_device( "squant", 0, 0, &squant );
+		if ( mas_error < 0 ) 
+			return close_with_error("error creating MAS squant device");
+
+		allocated_devices.push_back(squant);
+
+		mas_error = mas_asm_get_port_by_name( squant, "sink", &squant_sink );
+		if ( mas_error < 0 ) 
+			return close_with_error("error getting MAS squant device sink port");
+
+		allocated_ports.push_back(squant_sink);
+
+		mas_error = mas_asm_get_port_by_name( squant, "source", &squant_source );
+		if ( mas_error < 0 ) 
+			return close_with_error("error getting MAS squant device source port");
+        
+		allocated_ports.push_back(squant_source);
+
+        arts_debug( "MAS output: Connecting endian -> squant.");
+
+        masc_strike_dc( dc );
+        masc_setup_dc( dc, 6 );
+        masc_append_dc_key_value( dc,"format",(_format==8) ? "ulinear":"linear" );
+        masc_append_dc_key_value( dc, "resolution", resolutionstring );
+        masc_append_dc_key_value( dc, "sampling rate", ratestring );
+        masc_append_dc_key_value( dc, "channels", "2" );
+        masc_append_dc_key_value( dc, "endian", "host" );
+
+        mas_error = mas_asm_connect_source_sink( endian_source, squant_sink, dc );
+        if ( mas_error < 0 ) 
+			return close_with_error("error connecting MAS endian output to squant device");
+
+        /* sneaky: the squant device is optional -> pretend it isn't there */
+        open_source = squant_source;
+    }
+
+    
+    /* Another 'if necessary' device, as above */
+    if ( _samplingRate != 44100 )
+    {
+		arts_debug ("MAS output: Sample rate is not 44100, instantiating srate device.");
+
+		// srate, source & sink
+		mas_error = mas_asm_instantiate_device( "srate", 0, 0, &srate );
+		if ( mas_error < 0 ) 
+			return close_with_error("error initantiating MAS srate device");
+	
+		allocated_devices.push_back(srate);
+
+		mas_error = mas_asm_get_port_by_name( srate, "sink", &srate_sink );
+		if ( mas_error < 0 ) 
+			return close_with_error("error getting MAS srate sink port");
+
+		allocated_ports.push_back(srate_sink);
+
+		mas_error = mas_asm_get_port_by_name( srate, "source", &srate_source );
+		if ( mas_error < 0 ) 
+			return close_with_error("error getting MAS srate source port");
+
+		allocated_ports.push_back(srate_source);
+
+		arts_debug( "MAS output: Connecting to srate.");
+        
+		masc_strike_dc( dc );
+		masc_setup_dc( dc, 6 );
+		masc_append_dc_key_value( dc, "format", "linear" );
+		masc_append_dc_key_value( dc, "resolution", "16" );
+		masc_append_dc_key_value( dc, "sampling rate", ratestring );
+		masc_append_dc_key_value( dc, "channels", "2" );
+		masc_append_dc_key_value( dc, "endian", "host" );
+		
+		mas_error = mas_asm_connect_source_sink( open_source, srate_sink, dc );
+		if ( mas_error < 0 ) 
+			return close_with_error("error connecting to MAS srate device");
+
+        open_source = srate_source;        
+    }
+
+	// sbuf, source & sink
+    mas_error = mas_asm_instantiate_device( "sbuf", 0, 0, &sbuf );
+	if ( mas_error < 0 ) 
+		return close_with_error("error initantiating MAS sbuf device");
+
+	allocated_devices.push_back(sbuf);
+
+	mas_error = mas_asm_get_port_by_name( sbuf, "sink", &sbuf_sink );
+	if ( mas_error < 0 )
+		return close_with_error("error getting MAS sbuf device sink port");
+
+	allocated_ports.push_back(sbuf_sink);
+
+	mas_error = mas_asm_get_port_by_name( sbuf, "source", &sbuf_source );
+	if ( mas_error < 0 )
+		return close_with_error("error getting MAS sbuf device source port");
+
+	allocated_ports.push_back(sbuf_source);
+
+    masc_strike_dc( dc );
+    masc_setup_dc( dc, 6 );
+
+    masc_append_dc_key_value( dc, "format", "linear" );
+    masc_append_dc_key_value( dc, "resolution", "16" );
+    masc_append_dc_key_value( dc, "sampling rate", "44100" );
+    masc_append_dc_key_value( dc, "channels", "2" );
+    masc_append_dc_key_value( dc, "endian", "host" );
+
+	arts_debug("MAS output: Connecting to sbuf.");
+
+    mas_error = mas_asm_connect_source_sink( open_source, sbuf_sink, dc );
+    if ( mas_error < 0 ) 
+		return close_with_error("error connecting to MAS mixer device");
+
+	/* configure sbuf */
+
+	float BUFTIME_MS = _fragmentSize * _fragmentCount;
+	BUFTIME_MS *= 1000.0;
+	BUFTIME_MS /= (float)_channels;
+	if (_format > 8)
+		BUFTIME_MS /= 2.0;
+	BUFTIME_MS /= (float)_samplingRate;
+
+	arts_debug("MAS output: BUFTIME_MS = %f", BUFTIME_MS);
+
+	masc_setup_package( &package, NULL, 0, 0 );
+	masc_pushk_uint32( &package, "buftime_ms", (uint32) BUFTIME_MS );
+	masc_finalize_package( &package );
+	mas_set( sbuf, "buftime_ms", &package );
+	masc_strike_package( &package );
+
+	masc_setup_package( &package, NULL, 0, 0 );
+	masc_pushk_int32( &package, "mc_clkid", 9 );
+	masc_finalize_package( &package );
+	mas_set( sbuf, "mc_clkid", &package );
+	masc_strike_package( &package );
+
+	mas_source_play( sbuf );
+
+	// mix_sink
+   	mas_error = mas_asm_get_port_by_name( 0, "default_mix_sink", &mix_sink );
+	if (mas_error < 0)
+		return close_with_error("error finding MAS default sink");
+
+	allocated_ports.push_back(mix_sink);
+
+	arts_debug("MAS output: Connecting sbuf to mix_sink.");
+
+    mas_error = mas_asm_connect_source_sink( sbuf_source, mix_sink, dc );
+    if ( mas_error < 0 ) 
+		return close_with_error("error connecting to MAS mixer device");
+
+	data = (mas_data *)MAS_NEW( data );
+	masc_setup_data( data, _fragmentSize ); /* we can reuse this */
+	data->length = _fragmentSize;
+	data->allocated_length = data->length;
+	data->header.type = 10;
+
+    arts_debug("MAS output: playing.");
+ 
+    // Install the timer
+    Dispatcher::the()->ioManager()->addTimer(10, this);
+
+	bytesPerSec = _channels * _samplingRate;
+	if (_format > 8)
+		bytesPerSec *= 2;
+
+	lastUpdate = 0;
+
+    return true;
+} 
+
+double AudioIOMAS::currentTime()
+{
+	timeval tv;
+	gettimeofday(&tv,0);
+
+	return (double)tv.tv_sec + (double)tv.tv_usec/1000000.0;
+}
+
+bool AudioIOMAS::close_with_error(const string& text)
+{
+	string& error = paramStr(lastError);
+    error = text;
+	error += masc_strmerror (mas_error);
+	return false;
+}
+
+void AudioIOMAS::close()
+{
+	list<mas_port_t>::iterator pi;
+	for (pi = allocated_ports.begin(); pi != allocated_ports.end(); pi++)
+		mas_free_port (*pi);
+	allocated_ports.clear();
+
+	list<mas_channel_t>::iterator ci;
+	for (ci = allocated_channels.begin(); ci != allocated_channels.end(); ci++)
+		mas_free_channel (*ci);
+	allocated_channels.clear();
+
+	list<mas_device_t>::iterator di;
+	for (di = allocated_devices.begin(); di != allocated_devices.end(); di++)
+	{
+		mas_device_t device = *di;
+		mas_error = mas_asm_terminate_device_instance(device, 0);
+		if (mas_error < 0)
+			arts_warning ("MAS output: error while closing device: %s", masc_strmerror(mas_error));
+
+		mas_free_device(device);
+	}
+	allocated_devices.clear();
+
+    Dispatcher::the()->ioManager()->removeTimer(this);
+}
+
+void AudioIOMAS::updateBufferSizes()
+{
+	double time = currentTime();
+	double waterMark = param(fragmentSize);
+	waterMark *= 1.3;
+
+	if ((time - lastUpdate) * bytesPerSec < waterMark)
+		return;
+	
+	lastUpdate = time;
+
+	uint32	inbuf_ms;
+	int32	mas_error;
+
+	mas_error = mas_get( sbuf, "inbuf_ms", 0 , &package );
+	if ( mas_error < 0 )
+		arts_fatal ("MAS output: error getting size of buffer: %s", masc_strmerror(mas_error));
+
+	masc_pull_uint32( &package, &inbuf_ms );
+	masc_strike_package( &package );
+
+	//arts_debug("  inbuf_ms = %u", inbuf_ms);
+
+	float bytes = inbuf_ms;
+	bytes /= 1000.0;
+	bytes *= param(samplingRate);
+	bytes *= param(channels);
+	if(param(format) > 8)
+		bytes *= 2;
+
+	int bytesFree =  param(fragmentSize) * param(fragmentCount) - (int)bytes;
+
+	if (bytesFree < param(fragmentSize))
+		bytesFree = 0;
+
+	writeBufferAvailable = bytesFree;
+
+	arts_debug ("MAS output buffer: %6d / %6d bytes used => %6d bytes free",
+		(int)bytes, param(fragmentSize) * param(fragmentCount), writeBufferAvailable);
+}
+
+// This is called on each timer tick
+void AudioIOMAS::notifyTime()
+{
+	updateBufferSizes();
+
+    int& _direction = param(direction);
+    int& _fragmentSize = param(fragmentSize);
+
+    for (;;) {
+		int todo = 0;
+
+		if ((_direction & directionRead) && (getParam(canRead) >= _fragmentSize))
+		    todo |= AudioSubSystem::ioRead;
+
+		if ((_direction & directionWrite) && (getParam(canWrite) >= _fragmentSize))
+		    todo |= AudioSubSystem::ioWrite;
+
+		if (!todo)
+		    return;
+
+		AudioSubSystem::the()->handleIO(todo);
+    }
+}
+
+void AudioIOMAS::setParam(AudioParam p, int& value)
+{
+    switch(p) {
+#if 0
+    case fragmentSize:
+		param(p) = requestedFragmentSize = value;
+		break;
+    case fragmentCount:
+		param(p) = requestedFragmentCount = value;
+		break;
+#endif
+    default:
+		param(p) = value;
+		break;
+    }
+}
+
+int AudioIOMAS::getParam(AudioParam p)
+{
+    int bytes;
+    int count;
+
+    switch(p)
+    {
+#if 0
+    case canRead:
+		if (ioctl(audio_fd, AUDIO_GETINFO, &auinfo) < 0)
+		    return (0);
+		bytes = (auinfo.record.samples * bytesPerSample) - bytesRead;
+		if (bytes < 0) {
+		    printf("Error: bytes %d < 0, samples=%u, bytesRead=%u\n",
+				   bytes, auinfo.record.samples, bytesRead);
+		    bytes = 0;
+		}
+		return bytes;
+
+    case canWrite:
+		if (ioctl(audio_fd, AUDIO_GETINFO, &auinfo) < 0) 
+		    return (0);
+		count = SUN_MAX_BUFFER_SIZE - 
+		    (bytesWritten - (auinfo.play.samples * bytesPerSample));
+		return count;
+#endif
+    case canWrite:
+			return writeBufferAvailable;
+
+	case autoDetect:
+		/*
+		 * Fairly small priority, for we haven't tested this a lot
+		 */
+		return 3;
+
+    default:
+		return param(p);
+    }
+}
+
+int AudioIOMAS::read(void *buffer, int size)
+{
+#if 0
+    size = ::read(audio_fd, buffer, size);
+    if (size < 0)
+		return 0;
+
+    bytesRead += size;
+    return size;
+#endif
+	return 0;
+}
+
+int AudioIOMAS::write(void *buffer, int size)
+{
+	static int ts = 0;
+	static int seq = 0;
+	data->header.sequence = seq++;
+	data->header.media_timestamp = ts;
+	ts += size / 4;
+
+	assert(size == data->length);
+	memcpy(data->segment, buffer, size);
+
+	int32 mas_error = mas_send( audio_channel , data );
+	if (mas_error < 0)
+		arts_fatal ("MAS output: problem during mas_send: %s", masc_strmerror(mas_error));
+
+	writeBufferAvailable -= size;
+    return size;
+}
+
+#endif /* HAVE_LIBMAS */
diff --git a/flow/audioionas.cc b/flow/audioionas.cc
new file mode 100644
index 0000000..3106ade
--- /dev/null
+++ b/flow/audioionas.cc
@@ -0,0 +1,260 @@
+    /*
+
+    Copyright (C) 2001 Jochen Hoenicke
+                       jochen@gnu.org
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+ * only compile nas AudioIO class if libaudio was detected during
+ * configure
+ */
+#ifdef HAVE_LIBAUDIONAS
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "iomanager.h"
+#include "dispatcher.h"
+
+#include <audio/audiolib.h>
+
+namespace Arts {
+
+static AuBool
+eventHandler(AuServer *, AuEvent *ev, AuEventHandlerRec *handler);
+
+class AudioIONAS : public AudioIO, public IONotify {
+protected:
+	AuServer *aud;
+	AuDeviceID device;
+	AuFlowID flow;
+	AuElement elements[2];
+
+	int freeBytes;
+
+public:
+	AudioIONAS();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	void run();
+	void notifyIO(int, int);
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+
+	friend AuBool 
+	eventHandler(AuServer *, AuEvent *ev, AuEventHandlerRec *handler);
+};
+
+REGISTER_AUDIO_IO(AudioIONAS,"nas","Network Audio System");
+}
+
+using namespace std;
+using namespace Arts;
+
+static AuBool
+Arts::eventHandler(AuServer *, AuEvent *ev, AuEventHandlerRec *handler)
+{
+	AudioIONAS *nas = (AudioIONAS *) handler->data;
+	if (ev->type == AuEventTypeElementNotify)
+	{
+		AuElementNotifyEvent *event = (AuElementNotifyEvent *) ev;
+		
+		switch (event->kind)
+		{
+		case AuElementNotifyKindLowWater:
+			nas->freeBytes += event->num_bytes;
+			AudioSubSystem::the()->handleIO
+				(AudioSubSystem::ioWrite);
+			break;
+		case AuElementNotifyKindState:
+			if (event->cur_state ==  AuStatePause
+			    && event->reason != AuReasonUser)
+			{
+				nas->freeBytes += event->num_bytes;
+				AudioSubSystem::the()->handleIO
+					(AudioSubSystem::ioWrite);
+			}
+			break;
+		}
+	}
+	return true;
+}
+
+AudioIONAS::AudioIONAS()
+{
+	/*
+	 * default parameters
+	 */
+	param(samplingRate) = 11025;
+	paramStr(deviceName) = "null";
+	param(fragmentSize) = 1024;
+	param(fragmentCount) = 7;
+	param(format) = 16;
+	param(channels) = 2;
+	param(direction) = 2;
+}
+
+bool AudioIONAS::open()
+{
+	char *server_msg;
+	
+	int& _channels = param(channels);
+	int& _direction = param(direction);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+	string& _device = paramStr(deviceName);
+	string& _error = paramStr(lastError);
+	int  _buf_samples, i;
+
+	if((_direction & directionRead))
+	{
+		_error = "no record audio device";
+		return false;
+	}
+
+	aud = AuOpenServer(_device.compare("null") == 0 
+			   ? NULL : _device.c_str(), 
+			   0, NULL, 0, NULL, &server_msg);
+	if(aud == NULL)
+	{
+		_error = "device ";
+		_error += _device;
+		_error += " can't be opened (";
+		_error += server_msg;
+		_error += ")";
+		return false;
+	}
+
+	device = AuNone;
+	for (i = 0; i < AuServerNumDevices(aud); i++) 
+	{
+		AuDeviceAttributes *devattr = AuServerDevice(aud, i);
+		if (AuDeviceKind(devattr) == AuComponentKindPhysicalOutput
+		    && AuDeviceNumTracks(devattr) == _channels)
+		{
+			device = AuDeviceIdentifier(devattr);
+			break;
+		}
+	}
+				  
+	if (device == AuNone)
+	{
+		_error = "Couldn't find an output device";
+		return false;
+	}
+
+	if (!(flow = AuCreateFlow(aud, NULL)))
+	{
+		_error = "Couldn't create flow";
+		return false;
+	}
+
+	_buf_samples = _fragmentSize;
+	AuMakeElementImportClient(&elements[0], _samplingRate,
+				  _format == 8 ? AuFormatLinearUnsigned8
+				  : AuFormatLinearSigned16LSB,
+				  _channels, AuTrue,
+				  _buf_samples * _fragmentCount,
+				  _buf_samples * (_fragmentCount)/2,
+				  0, NULL);
+	AuMakeElementExportDevice(&elements[1], 0, device, _samplingRate,
+				  AuUnlimitedSamples, 0, NULL);
+	AuSetElements(aud, flow, AuTrue, 2, elements, NULL);
+	AuRegisterEventHandler(aud, AuEventHandlerIDMask, 0, flow,
+			       eventHandler, (AuPointer) this);
+
+	freeBytes = 0;
+	AuStartFlow(aud, flow, NULL);
+
+	Dispatcher::the()->ioManager()->watchFD(aud->fd, IOType::read, this);
+
+	AuHandleEvents(aud);
+	return true;
+}
+
+void AudioIONAS::close()
+{
+	Dispatcher::the()->ioManager()->remove(this, IOType::all);
+	AuWriteElement(aud, flow, 0, 0, NULL, AuTrue, NULL);
+	AuCloseServer(aud);
+	aud = NULL;
+}
+
+void AudioIONAS::setParam(AudioParam p, int& value)
+{
+	param(p) = value;
+}
+
+int AudioIONAS::getParam(AudioParam p)
+{
+	switch(p)
+	{
+	case canWrite:
+		return freeBytes;
+		
+	default:
+		return param(p);
+	}
+}
+
+void AudioIONAS::notifyIO(int, int)
+{
+	AuHandleEvents(aud);
+}
+
+int AudioIONAS::read(void *, int )
+{
+	return 0;
+}
+
+int AudioIONAS::write(void *buffer, int size)
+{
+	if (size > freeBytes)
+		size = freeBytes;
+	if (size > 0)
+		AuWriteElement(aud, flow, 0, size, buffer, AuFalse, NULL);
+	freeBytes -= size;
+	if (freeBytes > 0)
+		AudioSubSystem::the()->handleIO(AudioSubSystem::ioWrite);
+	return size;
+}
+
+#endif
diff --git a/flow/audioionull.cc b/flow/audioionull.cc
new file mode 100644
index 0000000..a8cd050
--- /dev/null
+++ b/flow/audioionull.cc
@@ -0,0 +1,184 @@
+    /*
+
+    Copyright (C) 2001 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+
+#include "debug.h"
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "iomanager.h"
+#include "dispatcher.h"
+
+namespace Arts {
+
+class AudioIONull : public AudioIO, public TimeNotify {
+protected:
+	timeval start;
+	double samplesRead, samplesWritten, bytesPerSec;
+
+public:
+	AudioIONull();
+
+	void notifyTime();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIONull,"null","No Audio Input/Output");
+}
+
+using namespace std;
+using namespace Arts;
+
+AudioIONull::AudioIONull()
+{
+	/*
+	 * default parameters
+	 */
+	param(samplingRate) = 44100;
+	paramStr(deviceName) = "null";
+	param(fragmentSize) = 1024;
+	param(fragmentCount) = 7;
+	param(channels) = 2;
+	param(direction) = 2;
+}
+
+bool AudioIONull::open()
+{
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+	_format = 16;
+
+	/*
+	 * don't allow unreasonable large fragmentSize/Count combinations,
+	 * because "real" hardware also doesn't
+	 */
+
+	if(_fragmentSize > 1024*128) _fragmentSize = 1024*128;
+
+	while(_fragmentSize * _fragmentCount > 1024*128)
+		_fragmentCount--;
+
+	Dispatcher::the()->ioManager()->addTimer(10, this);
+
+	samplesRead = samplesWritten = 0.0;
+	bytesPerSec = _channels * 2 * _samplingRate;
+	gettimeofday(&start,0);
+
+	return true;
+}
+
+void AudioIONull::close()
+{
+	Dispatcher::the()->ioManager()->removeTimer(this);
+}
+
+void AudioIONull::notifyTime()
+{
+	int& _direction = param(direction);
+	int& _fragmentSize = param(fragmentSize);
+
+	for(;;)
+	{
+		int todo = 0;
+
+		if((_direction & directionRead) && getParam(canRead) >= _fragmentSize)
+			todo |= AudioSubSystem::ioRead;
+
+		if((_direction & directionWrite) && getParam(canWrite) >= _fragmentSize)
+			todo |= AudioSubSystem::ioWrite;
+
+		if(!todo)
+			return;
+
+		AudioSubSystem::the()->handleIO(todo);
+	}
+}
+
+void AudioIONull::setParam(AudioParam p, int& value)
+{
+	param(p) = value;
+}
+
+int AudioIONull::getParam(AudioParam p)
+{
+	timeval now;
+	double delta;
+	int bytes;
+
+	switch(p)
+	{
+		case canRead:
+		case canWrite:
+				gettimeofday(&now,0);
+				delta = (double)now.tv_sec + (double)now.tv_usec/1000000.0;
+				delta -= (double)start.tv_sec + (double)start.tv_usec/1000000.0;
+				bytes = (int)( (delta * bytesPerSec)
+								 -  ((p == canRead)?samplesRead:samplesWritten)
+								  );
+				return bytes;
+			break;
+
+		default:
+				return param(p);
+			break;
+	}
+}
+
+int AudioIONull::read(void *buffer, int size)
+{
+	samplesRead += size;
+	memset(buffer, 0, size);
+	return size;
+}
+
+int AudioIONull::write(void *, int size)
+{
+	samplesWritten += size;
+	return size;
+}
diff --git a/flow/audioiooss.cc b/flow/audioiooss.cc
new file mode 100644
index 0000000..214cd3b
--- /dev/null
+++ b/flow/audioiooss.cc
@@ -0,0 +1,485 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+	#include <config.h>
+#endif
+
+#if defined(HAVE_SYS_SOUNDCARD_H)
+	#include <sys/soundcard.h>
+	#define COMPILE_AUDIOIO_OSS 1
+#elif defined(HAVE_SOUNDCARD_H)
+	#include <soundcard.h>
+	#define COMPILE_AUDIOIO_OSS 1
+#endif
+
+/**
+ * only compile 'oss' AudioIO class if sys/soundcard.h or soundcard.h is present
+ */
+#ifdef COMPILE_AUDIOIO_OSS
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_SYS_SELECT_H
+	#include <sys/select.h>		// Needed on some systems.
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+
+#include "debug.h"
+#include "audioio.h"
+
+namespace Arts {
+
+class AudioIOOSS : public AudioIO {
+protected:
+	int audio_fd;
+	int requestedFragmentSize;
+	int requestedFragmentCount;
+
+	std::string findDefaultDevice();
+	int ossBits(int format);
+
+public:
+	AudioIOOSS();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+REGISTER_AUDIO_IO(AudioIOOSS,"oss","Open Sound System");
+}
+
+using namespace std;
+using namespace Arts;
+
+/*
+ * Tries to figure out which is the OSS device we should write to
+ */
+string AudioIOOSS::findDefaultDevice()
+{
+	static const char *device[] = {
+		"/dev/dsp",					/* The usual device */
+		// how does access(2) deal with a directory?
+		// I don't know,  but, since /dev/sound/dsp is a linux bogosity
+	#if defined(__linux__)
+		"/dev/sound/dsp",				/* Linux with devfs-only installation */
+	#else
+		"/dev/sound",					/* NetBSD */
+	#endif
+		"/dev/audio",					/* OpenBSD */
+		0
+	};
+
+	for(int i = 0; device[i]; i++)
+		if(access(device[i],F_OK) == 0)
+			return device[i];
+
+	// Should this really return a valid device if we have access to none?
+	return device[0];
+}
+
+int AudioIOOSS::ossBits(int format)
+{
+	arts_return_val_if_fail (format == AFMT_U8
+			              || format == AFMT_S16_LE
+						  || format == AFMT_S16_BE, 16);
+
+	return (format == AFMT_U8)?8:16;
+}
+
+AudioIOOSS::AudioIOOSS()
+{
+	/*
+	 * default parameters
+	 */
+	param(samplingRate) = 44100;
+	paramStr(deviceName) = findDefaultDevice();
+	requestedFragmentSize = param(fragmentSize) = 1024;
+	requestedFragmentCount = param(fragmentCount) = 7;
+	param(channels) = 2;
+	param(direction) = 2;
+}
+
+bool AudioIOOSS::open()
+{
+	string& _error = paramStr(lastError);
+	string& _deviceName = paramStr(deviceName);
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+
+	int mode;
+
+	if(param(direction) == 3)
+		mode = O_RDWR|O_NDELAY;
+	else if(param(direction) == 2)
+		mode = O_WRONLY|O_NDELAY;
+	else
+	{
+		_error = "invalid direction";
+		return false;
+	}
+
+	audio_fd = ::open(_deviceName.c_str(), mode, 0);
+
+	if(audio_fd == -1)
+	{
+		_error = "device ";
+		_error += _deviceName.c_str();
+		_error += " can't be opened (";
+		_error += strerror(errno);
+		_error += ")";
+		return false;
+	}
+	/*
+	 * check device capabilities
+	 */
+	int device_caps;
+	if(ioctl(audio_fd,SNDCTL_DSP_GETCAPS,&device_caps) == -1)
+            device_caps=0;
+
+	string caps = "";
+	if(device_caps & DSP_CAP_DUPLEX) caps += "duplex ";
+	if(device_caps & DSP_CAP_REALTIME) caps += "realtime ";
+	if(device_caps & DSP_CAP_BATCH) caps += "batch ";
+	if(device_caps & DSP_CAP_COPROC) caps += "coproc ";
+	if(device_caps & DSP_CAP_TRIGGER) caps += "trigger ";
+	if(device_caps & DSP_CAP_MMAP) caps += "mmap ";
+	artsdebug("device capabilities: revision%d %s",
+					device_caps & DSP_CAP_REVISION, caps.c_str());
+
+	int requestedFormat = (_format == 8)?AFMT_U8:AFMT_S16_LE;
+	int gotFormat = requestedFormat;
+	if (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &gotFormat)==-1)  
+	{
+		_error = "SNDCTL_DSP_SETFMT failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+	}  
+
+	if (_format && (ossBits(gotFormat) != ossBits(requestedFormat)))
+	{  
+		char details[80];
+		sprintf(details," (_format = %d, asked driver to give %d, got %d)",
+			_format, requestedFormat, gotFormat);
+
+		_error = "Can't set playback format";
+		_error += details;
+
+		close();
+		return false;
+	}
+
+	if(gotFormat == AFMT_U8)
+		_format = 8;
+	else if(gotFormat == AFMT_S16_LE)
+		_format = 16;
+	else if(gotFormat == AFMT_S16_BE)
+		_format = 17;
+	else
+	{
+		char details[80];
+		sprintf(details," (_format = %d, asked driver to give %d, got %d)",
+			_format, requestedFormat, gotFormat);
+
+		_error = "unknown format given by driver";
+		_error += details;
+
+		close();
+		return false;
+	}
+
+
+	int stereo=-1;     /* 0=mono, 1=stereo */
+
+	if(_channels == 1)
+	{
+		stereo = 0;
+	}
+	if(_channels == 2)
+	{
+		stereo = 1;
+	}
+
+	if(stereo == -1)
+	{
+		_error = "internal error; set channels to 1 (mono) or 2 (stereo)";
+
+		close();
+		return false;
+	}
+
+	int requeststereo = stereo;
+
+	if (ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo)==-1)
+	{
+		_error = "SNDCTL_DSP_STEREO failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+	}
+
+	if (requeststereo != stereo)
+	{
+		_error = "audio device doesn't support number of requested channels";
+
+		close();
+		return false;
+	}
+
+	int speed = _samplingRate;
+
+	if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &speed)==-1)  
+	{
+		_error = "SNDCTL_DSP_SPEED failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+	}  
+
+    /*
+	 * Some soundcards seem to be able to only supply "nearly" the requested
+	 * sampling rate, especially PAS 16 cards seem to quite radical supplying
+	 * something different than the requested sampling rate ;)
+	 *
+	 * So we have a quite large tolerance here (when requesting 44100 Hz, it
+	 * will accept anything between 38690 Hz and 49510 Hz). Most parts of the
+	 * aRts code will do resampling where appropriate, so it shouldn't affect
+	 * sound quality.
+	 */
+    int tolerance = _samplingRate/10+1000;
+
+	if (abs(speed-_samplingRate) > tolerance)
+	{  
+		_error = "can't set requested samplingrate";
+
+		char details[80];
+		sprintf(details," (requested rate %d, got rate %d)",
+			_samplingRate, speed);
+		_error += details;
+
+		close();
+		return false;
+	} 
+	_samplingRate = speed;
+
+	/*
+	 * set the fragment settings to what the user requested
+	 */
+	
+	_fragmentSize = requestedFragmentSize;
+	_fragmentCount = requestedFragmentCount;
+
+	/*
+	 * lower 16 bits are the fragment size (as 2^S)
+	 * higher 16 bits are the number of fragments
+	 */
+	int frag_arg = 0;
+
+	int size = _fragmentSize;
+	while(size > 1) { size /= 2; frag_arg++; }
+	frag_arg += (_fragmentCount << 16);
+	if(ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_arg) == -1)
+	{
+		char buffer[1024];
+		_error = "can't set requested fragments settings";
+		sprintf(buffer,"size%d:count%d\n",_fragmentSize,_fragmentCount);
+		close();
+		return false;
+	}
+
+	/*
+	 * now see what we really got as cards aren't required to supply what
+	 * we asked for
+	 */
+	audio_buf_info info;
+	if(ioctl(audio_fd,SNDCTL_DSP_GETOSPACE, &info) == -1)
+	{
+		_error = "can't retrieve fragment settings";
+		close();
+		return false;
+	}
+
+	// update fragment settings with what we got
+	_fragmentSize = info.fragsize;
+	_fragmentCount = info.fragstotal;
+
+	artsdebug("buffering: %d fragments with %d bytes "
+		"(audio latency is %1.1f ms)", _fragmentCount, _fragmentSize,
+		(float)(_fragmentSize*_fragmentCount) /
+		(float)(2.0 * _samplingRate * _channels)*1000.0);
+
+	/*
+	 * Workaround for broken kernel drivers: usually filling up the audio
+	 * buffer is _only_ required if _fullDuplex is true. However, there
+	 * are kernel drivers around (especially everything related to ES1370/1371)
+	 * which will not trigger select()ing the file descriptor unless we have
+	 * written something first.
+	 */
+	char *zbuffer = (char *)calloc(sizeof(char), _fragmentSize);
+	if(_format == 8)
+		for(int zpos = 0; zpos < _fragmentSize; zpos++)
+			zbuffer[zpos] |= 0x80;
+	
+	for(int fill = 0; fill < _fragmentCount; fill++)
+	{
+		int len = write(zbuffer,_fragmentSize);
+		if(len != _fragmentSize)
+		{
+			arts_debug("AudioIOOSS: failed prefilling audio buffer (might cause synchronization problems in conjunction with full duplex)");
+			fill = _fragmentCount+1;
+		}
+	}
+	free(zbuffer);
+
+	/*
+	 * Triggering - the original aRts code did this for full duplex:
+	 *
+	 *  - stop audio i/o using SETTRIGGER(~(PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT))
+	 *  - fill buffer (see zbuffer code two lines above)
+	 *  - start audio i/o using SETTRIGGER(PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT)
+	 *
+	 * this should guarantee synchronous start of input/output. Today, it
+	 * seems there are too many broken drivers around for this.
+	 */
+
+	if(device_caps & DSP_CAP_TRIGGER)
+	{
+		int enable_bits = 0;
+
+		if(param(direction) & 1) enable_bits |= PCM_ENABLE_INPUT;
+		if(param(direction) & 2) enable_bits |= PCM_ENABLE_OUTPUT;
+
+		if(ioctl(audio_fd,SNDCTL_DSP_SETTRIGGER, &enable_bits) == -1)
+		{
+			_error = "can't start sound i/o";
+
+			close();
+			return false;
+		}
+	}
+	return true;
+}
+
+void AudioIOOSS::close()
+{
+	::close(audio_fd);
+}
+
+void AudioIOOSS::setParam(AudioParam p, int& value)
+{
+	switch(p)
+	{
+		case fragmentSize:
+				param(p) = requestedFragmentSize = value;
+			break;
+		case fragmentCount:
+				param(p) = requestedFragmentCount = value;
+			break;
+		default:
+				param(p) = value;
+			break;
+	}
+}
+
+int AudioIOOSS::getParam(AudioParam p)
+{
+	audio_buf_info info;
+	switch(p)
+	{
+		case canRead:
+				ioctl(audio_fd, SNDCTL_DSP_GETISPACE, &info);
+				return info.bytes;
+			break;
+
+		case canWrite:
+				ioctl(audio_fd, SNDCTL_DSP_GETOSPACE, &info);
+				return info.bytes;
+			break;
+
+		case selectReadFD:
+				return (param(direction) & directionRead)?audio_fd:-1;
+			break;
+
+		case selectWriteFD:
+				return (param(direction) & directionWrite)?audio_fd:-1;
+			break;
+
+		case autoDetect:
+				/* OSS works reasonable almost everywhere where it compiles */
+				return 10;	
+			break;
+
+		default:
+				return param(p);
+			break;
+	}
+}
+
+int AudioIOOSS::read(void *buffer, int size)
+{
+	arts_assert(audio_fd != 0);
+
+	int result;
+	do {
+		result = ::read(audio_fd,buffer,size);
+	} while(result == -1 && errno == EINTR);
+
+	return result;
+}
+
+int AudioIOOSS::write(void *buffer, int size)
+{
+	arts_assert(audio_fd != 0);
+
+	int result;
+	do {
+		result = ::write(audio_fd,buffer,size);
+	} while(result == -1 && errno == EINTR);
+
+	return result;
+}
+
+#endif
diff --git a/flow/audioioossthreaded.cc b/flow/audioioossthreaded.cc
new file mode 100644
index 0000000..9b63c4a
--- /dev/null
+++ b/flow/audioioossthreaded.cc
@@ -0,0 +1,681 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    Multithreading support by
+        Matthias Welwarsky <matze@stud.fbi.fh-darmstadt.de>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_SYS_SOUNDCARD_H
+#include <sys/soundcard.h>
+#define COMPILE_AUDIOIO_OSS 1
+#endif
+
+#ifdef HAVE_SOUNDCARD_H
+#include <soundcard.h>
+#define COMPILE_AUDIOIO_OSS 1
+#endif
+
+/**
+ * only compile 'oss' AudioIO class if sys/soundcard.h or soundcard.h is present
+ * also, only compile if libpthread was found
+ */
+#if defined(COMPILE_AUDIOIO_OSS) && defined(HAVE_LIBPTHREAD)
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <cstring>
+#include <algorithm>
+
+#include "debug.h"
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "iomanager.h"
+#include "dispatcher.h"
+
+// thread safe data queue implementation
+#include "thread.h"
+#include "bufferqueue.h"
+
+namespace Arts {
+
+class AudioIOOSSThreaded : public AudioIO, public TimeNotify {
+private:
+	class ReaderThread : public Arts::Thread {
+	public:
+		void run();
+		bool isRunning() { return runThread; }
+		void stop() { runThread = false; }
+		void setParent(AudioIOOSSThreaded* instance) { parent = instance; }
+
+	private:
+		bool runThread;
+		AudioIOOSSThreaded* parent;
+	};
+
+	class WriterThread : public Arts::Thread {
+	public:
+		void run();
+		bool isRunning() { return runThread; }
+		void stop() { runThread = false; }
+		void setParent(AudioIOOSSThreaded* instance) { parent = instance; }
+
+	private:
+		bool runThread;
+		AudioIOOSSThreaded* parent;
+	};
+
+	friend class ReaderThread;
+	friend class WriterThread;
+
+	void startThread();
+	void stopThread();
+
+	BufferQueue readerQueue;
+	BufferQueue writerQueue;
+
+	ReaderThread readerThread;
+	WriterThread writerThread;
+
+protected:
+	int audio_fd;
+	int requestedFragmentSize;
+	int requestedFragmentCount;
+
+	std::string findDefaultDevice();
+	int ossBits(int format);
+
+public:
+	AudioIOOSSThreaded();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+
+	void notifyTime();
+};
+
+REGISTER_AUDIO_IO(AudioIOOSSThreaded,"toss","Threaded Open Sound System");
+}
+
+using namespace std;
+using namespace Arts;
+
+/*
+ * Tries to figure out which is the OSS device we should write to
+ */
+string AudioIOOSSThreaded::findDefaultDevice()
+{
+	static const char *device[] = {
+		"/dev/dsp",						/* Linux (and lots of others) */
+		"/dev/sound/dsp0",				/* Linux with devfs-only installation */
+		"/dev/audio",					/* OpenBSD */
+		0
+	};
+
+	for(int i = 0; device[i]; i++)
+		if(access(device[i],F_OK) == 0)
+			return device[i];
+
+	return device[0];
+}
+
+int AudioIOOSSThreaded::ossBits(int format)
+{
+	arts_return_val_if_fail (format == AFMT_U8
+			              || format == AFMT_S16_LE
+						  || format == AFMT_S16_BE, 16);
+
+	return (format == AFMT_U8)?8:16;
+}
+
+AudioIOOSSThreaded::AudioIOOSSThreaded()
+{
+	/*
+	 * default parameters
+	 */
+	param(samplingRate) = 44100;
+	paramStr(deviceName) = findDefaultDevice();
+	requestedFragmentSize = param(fragmentSize) = 1024;
+	requestedFragmentCount = param(fragmentCount) = 7;
+	param(channels) = 2;
+	param(direction) = 2;
+}
+
+bool AudioIOOSSThreaded::open()
+{
+	string& _error = paramStr(lastError);
+	string& _deviceName = paramStr(deviceName);
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+
+	if (!SystemThreads::supported()) {
+		_error = "System does not support multithreading";
+		return false;
+	}
+
+	int mode;
+
+	if(param(direction) == 3)
+		mode = O_RDWR;
+	else if(param(direction) == 2)
+		mode = O_WRONLY;
+	else
+	{
+		_error = "invalid direction";
+		return false;
+	}
+
+	audio_fd = ::open(_deviceName.c_str(), mode, 0);
+
+	if(audio_fd == -1)
+	{
+		_error = "device ";
+		_error += _deviceName.c_str();
+		_error += " can't be opened (";
+		_error += strerror(errno);
+		_error += ")";
+		return false;
+	}
+	/*
+	 * check device capabilities
+	 */
+	int device_caps;
+	if(ioctl(audio_fd,SNDCTL_DSP_GETCAPS,&device_caps) == -1)
+		device_caps=0;
+
+	string caps = "";
+	if(device_caps & DSP_CAP_DUPLEX) caps += "duplex ";
+	if(device_caps & DSP_CAP_REALTIME) caps += "realtime ";
+	if(device_caps & DSP_CAP_BATCH) caps += "batch ";
+	if(device_caps & DSP_CAP_COPROC) caps += "coproc ";
+	if(device_caps & DSP_CAP_TRIGGER) caps += "trigger ";
+	if(device_caps & DSP_CAP_MMAP) caps += "mmap ";
+	artsdebug("device capabilities: revision%d %s",
+			device_caps & DSP_CAP_REVISION, caps.c_str());
+
+	int requestedFormat = (_format == 8)?AFMT_U8:AFMT_S16_LE;
+	int gotFormat = requestedFormat;
+	if (ioctl(audio_fd, SNDCTL_DSP_SETFMT, &gotFormat)==-1)
+	{
+		_error = "SNDCTL_DSP_SETFMT failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+	}
+
+	if (_format && (ossBits(gotFormat) != ossBits(requestedFormat)))
+	{
+		char details[80];
+		sprintf(details," (_format = %d, asked driver to give %d, got %d)",
+				_format, requestedFormat, gotFormat);
+
+		_error = "Can't set playback format";
+		_error += details;
+
+		close();
+		return false;
+	}
+
+	if(gotFormat == AFMT_U8)
+		_format = 8;
+	else if(gotFormat == AFMT_S16_LE)
+		_format = 16;
+	else if(gotFormat == AFMT_S16_BE)
+		_format = 17;
+	else
+	{
+		char details[80];
+		sprintf(details," (_format = %d, asked driver to give %d, got %d)",
+				_format, requestedFormat, gotFormat);
+
+		_error = "unknown format given by driver";
+		_error += details;
+
+		close();
+		return false;
+	}
+
+
+	int stereo=-1;     /* 0=mono, 1=stereo */
+
+	if(_channels == 1)
+	{
+		stereo = 0;
+	}
+	if(_channels == 2)
+	{
+		stereo = 1;
+	}
+
+	if(stereo == -1)
+	{
+		_error = "internal error; set channels to 1 (mono) or 2 (stereo)";
+
+		close();
+		return false;
+	}
+
+	int requeststereo = stereo;
+
+	if (ioctl(audio_fd, SNDCTL_DSP_STEREO, &stereo)==-1)
+	{
+		_error = "SNDCTL_DSP_STEREO failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+	}
+
+	if (requeststereo != stereo)
+	{
+		_error = "audio device doesn't support number of requested channels";
+
+		close();
+		return false;
+	}
+
+	int speed = _samplingRate;
+
+	if (ioctl(audio_fd, SNDCTL_DSP_SPEED, &speed)==-1)
+	{
+		_error = "SNDCTL_DSP_SPEED failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+	}
+
+	/*
+	 * Some soundcards seem to be able to only supply "nearly" the requested
+	 * sampling rate, especially PAS 16 cards seem to quite radical supplying
+	 * something different than the requested sampling rate ;)
+	 *
+	 * So we have a quite large tolerance here (when requesting 44100 Hz, it
+	 * will accept anything between 38690 Hz and 49510 Hz). Most parts of the
+	 * aRts code will do resampling where appropriate, so it shouldn't affect
+	 * sound quality.
+	 */
+	int tolerance = _samplingRate/10+1000;
+
+	if (abs(speed-_samplingRate) > tolerance)
+	{
+		_error = "can't set requested samplingrate";
+
+		char details[80];
+		sprintf(details," (requested rate %d, got rate %d)",
+				_samplingRate, speed);
+		_error += details;
+
+		close();
+		return false;
+	}
+	_samplingRate = speed;
+
+	/*
+	 * set the fragment settings to what the user requested
+	 */
+
+	_fragmentSize = requestedFragmentSize;
+	_fragmentCount = requestedFragmentCount;
+
+	/*
+	 * lower 16 bits are the fragment size (as 2^S)
+	 * higher 16 bits are the number of fragments
+	 */
+	unsigned int frag_arg = 0;
+
+	unsigned int size = _fragmentSize;
+	while(size > 1) { size /= 2; frag_arg++; }
+	frag_arg += (_fragmentCount << 16);
+
+	//////////////////////////////////////////////////////////////////////
+	// MW
+	// stopping here because the fragment settings cannot be done
+	// is not sensible. Especially not as we check the settings in the
+	// very next step. We should handle this gracefully.
+	//
+	ioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &frag_arg);
+
+	/*
+	 * now see what we really got as cards aren't required to supply what
+	 * we asked for
+	 */
+	audio_buf_info info;
+	if(ioctl(audio_fd,SNDCTL_DSP_GETOSPACE, &info) == -1)
+	{
+		_error = "can't retrieve fragment settings";
+		close();
+		return false;
+	}
+
+	// update fragment settings with what we got
+	//_fragmentSize = info.fragsize;
+	//_fragmentCount = info.fragstotal;
+
+	fprintf(stderr, "buffering: fragsize:%d fragstotal:%d\n",
+			_fragmentSize, _fragmentCount);
+
+	artsdebug("buffering: %d fragments with %d bytes "
+			"(audio latency is %1.1f ms)", _fragmentCount, _fragmentSize,
+			(float)(_fragmentSize*_fragmentCount) /
+			(float)(2.0 * _samplingRate * _channels)*1000.0);
+
+	// set the chunk size of the buffer queues.
+	readerQueue.setChunkSize(_fragmentSize);
+	writerQueue.setChunkSize(_fragmentSize);
+
+	/*
+	 * Workaround for broken kernel drivers: usually filling up the audio
+	 * buffer is _only_ required if _fullDuplex is true. However, there
+	 * are kernel drivers around (especially everything related to ES1370/1371)
+	 * which will not trigger select()ing the file descriptor unless we have
+	 * written something first.
+	 */
+	char *zbuffer = (char *)calloc(sizeof(char), _fragmentSize);
+	if(_format == 8)
+		for(int zpos = 0; zpos < _fragmentSize; zpos++)
+			zbuffer[zpos] |= 0x80;
+
+	for(int fill = 0; fill < _fragmentCount; fill++)
+	{
+		int len = ::write(audio_fd,zbuffer,_fragmentSize);
+		if(len != _fragmentSize)
+		{
+			arts_debug("AudioIOOSSThreaded: failed prefilling audio buffer (might cause synchronization problems in conjunction with full duplex)");
+			fill = _fragmentCount+1;
+		}
+	}
+	free(zbuffer);
+
+	/*
+	 * Triggering - the original aRts code did this for full duplex:
+	 *
+	 *  - stop audio i/o using SETTRIGGER(~(PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT))
+	 *  - fill buffer (see zbuffer code two lines above
+	 *  - start audio i/o using SETTRIGGER(PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT)
+	 *
+	 * this should guarantee synchronous start of input/output. Today, it
+	 * seems there are too many broken drivers around for this.
+	 */
+
+	if(device_caps & DSP_CAP_TRIGGER)
+	{
+		int enable_bits = 0;
+
+		if(param(direction) & 1) enable_bits |= PCM_ENABLE_INPUT;
+		if(param(direction) & 2) enable_bits |= PCM_ENABLE_OUTPUT;
+
+		if(ioctl(audio_fd,SNDCTL_DSP_SETTRIGGER, &enable_bits) == -1)
+		{
+			_error = "can't start of sound i/o operation";
+
+			close();
+			return false;
+		}
+	}
+
+	startThread();
+
+	Dispatcher::the()->ioManager()->addTimer(10, this);
+
+	return true;
+}
+
+void AudioIOOSSThreaded::close()
+{
+	fprintf(stderr, "AudioIO::close(): entering\n");
+	Dispatcher::the()->ioManager()->removeTimer(this);
+
+	::close(audio_fd);
+	stopThread();
+	fprintf(stderr, "AudioIO::close(): leaving\n");
+}
+
+void AudioIOOSSThreaded::notifyTime()
+{
+	int& _direction = param(direction);
+
+	for(int i=0; i < 3; i++) {
+		int todo = 0;
+
+		if((_direction & directionRead) && getParam(canRead) > 0)
+			todo |= AudioSubSystem::ioRead;
+
+		if((_direction & directionWrite) && getParam(canWrite) > 0)
+			todo |= AudioSubSystem::ioWrite;
+
+		//fprintf(stderr, "AudioIO: can write %d, fragment size %d, todo %d\n",
+		//	getParam(canWrite), _fragmentSize, todo);
+
+		if(!todo) // break endless loop
+			break;
+
+		AudioSubSystem::the()->handleIO(todo);
+	}
+}
+
+void AudioIOOSSThreaded::setParam(AudioParam p, int& value)
+{
+	switch(p) {
+		case fragmentSize:
+			param(p) = requestedFragmentSize = value;
+			break;
+
+		case fragmentCount:
+			param(p) = requestedFragmentCount = value;
+			break;
+
+		default:
+			param(p) = value;
+			break;
+	}
+}
+
+int AudioIOOSSThreaded::getParam(AudioParam p)
+{
+	switch(p) {
+		case canRead:
+			return readerQueue.bufferedChunks() * readerQueue.chunkSize();
+			break;
+
+		case canWrite:
+			return writerQueue.freeChunks() * writerQueue.chunkSize();
+			break;
+
+		case autoDetect:
+			/* It compiles, but Posix Threads don't work everywhere */
+			return 4;
+			break;
+
+		default:
+			return param(p);
+			break;
+	}
+}
+
+int AudioIOOSSThreaded::read(void *buffer, int size)
+{
+	int copied = 0;
+	int copySize;
+	ByteBuffer* tmpBuf = 0;
+	while (size > 0) {
+		if (!tmpBuf)
+			tmpBuf = readerQueue.waitProduced();
+
+		copySize = (size > tmpBuf->size())? tmpBuf->size():size;
+		memcpy(((char*)buffer)+copied, tmpBuf->get(), copySize);
+
+		if (tmpBuf->push(copySize) == 0) {
+			tmpBuf = 0;
+			readerQueue.consumed();
+		}
+
+		copied += copySize;
+		size   -= copySize;
+	}
+	return copied;
+}
+
+int AudioIOOSSThreaded::write(void *buffer, int size)
+{
+	int copied = 0;
+	while (size > 0) {
+		int copySize = (size > writerQueue.chunkSize())?writerQueue.chunkSize():size;
+		if (!writerQueue.freeChunks())
+			fprintf(stderr, "AudioIO::write will block!\n");
+		writerQueue.write(buffer, copySize);
+		copied += copySize;
+		size   -= copySize;
+	}
+	return copied;
+}
+
+/*
+ * posix thread to feed the audio device
+ */
+
+void AudioIOOSSThreaded::WriterThread::run()
+{
+	fprintf(stderr, "AudioIOOSSThreaded::writerThread() thread started\n");
+
+	setPriority(45);
+
+	runThread = true;
+
+	ssize_t size;
+	ByteBuffer* tmpBuf = 0;
+	while (runThread) {
+
+		if (!tmpBuf) {
+			tmpBuf = parent->writerQueue.waitProduced();
+
+			if (!tmpBuf->size()) {
+				tmpBuf = NULL;
+				parent->writerQueue.consumed();
+				continue;
+			}
+		}
+
+		size = ::write(parent->audio_fd, tmpBuf->get(), tmpBuf->size());
+
+		if (size >= 0) {
+			if (tmpBuf->push(size) == 0) {
+				tmpBuf = NULL;
+				parent->writerQueue.consumed();
+			}
+		} else if (errno != EINTR) {
+			// this is a fatal error. we cannot write to the fd any more.
+			runThread = false;
+			fprintf(stderr, "AudioIOOSSTHreaded::writerThread() fatal error writing to audio_fd\n");
+		}
+	}
+	fprintf(stderr, "AudioIOOSSThreaded::writerThread() thread stopped\n");
+}
+
+/*
+ * posix thread to read the audio device
+ */
+void AudioIOOSSThreaded::ReaderThread::run()
+{
+	fprintf(stderr, "AudioIOOSSThreaded::readerThread() thread started\n");
+
+	runThread = true;
+
+	ByteBuffer* tmpBuf;
+	ssize_t size;
+	while (runThread) {
+		tmpBuf = parent->readerQueue.waitConsumed();
+
+		size = ::read(parent->audio_fd, tmpBuf->reset(), tmpBuf->maxSize());
+
+		if (size >= 0) {
+			tmpBuf->set(size);
+			parent->readerQueue.produced();
+		} else if (errno != EINTR) {
+			runThread = false;
+			fprintf(stderr, "AudioIOOSSTHreaded::readerThread() fatal error reading from audio_fd\n");
+		}
+	}
+	fprintf(stderr, "AudioIOOSSThreaded::readerThread() thread stopped\n");
+}
+
+void AudioIOOSSThreaded::startThread()
+{
+	fprintf(stderr, "AudioIOOSSThreaded::startThread(): entering\n");
+
+	if (param(direction) & directionWrite) {
+		writerThread.setParent(this);
+		writerThread.start();
+	}
+	if (param(direction) & directionRead) {
+		readerThread.setParent(this);
+		readerThread.start();
+	}
+
+	fprintf(stderr, "AudioIOOSSThreaded::startThread(): leaving\n");
+}
+
+void AudioIOOSSThreaded::stopThread()
+{
+	fprintf(stderr, "AudioIOOSSThreaded::stopThread() entering\n");
+
+	if (param(direction) & directionWrite) {
+		writerThread.stop();
+		// make sure there's something to write, avoids race condition
+		if (writerQueue.isEmpty())
+			writerQueue.write(NULL, 0);
+		fprintf(stderr, "waiting for writerThread to finish\n");
+		writerThread.waitDone();
+		writerQueue.clear();
+	}
+
+	if (param(direction) & directionRead) {
+		readerThread.stop();
+		fprintf(stderr, "waiting for readerThread to finish\n");
+		readerThread.waitDone();
+		readerQueue.clear();
+	}
+
+	fprintf(stderr, "AudioIOOSSThreaded::stopThread(): leaving\n");
+}
+
+#endif
diff --git a/flow/audioiosgi.cc b/flow/audioiosgi.cc
new file mode 100644
index 0000000..96a677c
--- /dev/null
+++ b/flow/audioiosgi.cc
@@ -0,0 +1,274 @@
+    /*
+
+    Copyright (C) 2001 Carsten Kroll
+                       ckroll@pinnaclesys.com
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/**
+ * only compile 'sgi' AudioIO class if compiled under IRIX
+ */
+#ifdef HAVE_IRIX
+
+#include <dmedia/audio.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>		// Needed on some systems.
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+
+#include "debug.h"
+#include "audioio.h"
+
+namespace Arts {
+
+class AudioIOSGI : public AudioIO {
+protected:
+	int requestedFragmentSize;
+	int requestedFragmentCount;
+	ALport audio_port,audio_port1;
+	ALconfig audioconfig;
+	int framesz;
+
+public:
+	AudioIOSGI();
+
+	void setParam(AudioParam param, int& value);
+	int getParam(AudioParam param);
+
+	bool open();
+	void close();
+	int read(void *buffer, int size);
+	int write(void *buffer, int size);
+};
+
+
+REGISTER_AUDIO_IO(AudioIOSGI,"sgi","SGI dmedia Audio I/O");
+};
+
+using namespace std;
+using namespace Arts;
+
+AudioIOSGI::AudioIOSGI()
+{
+	/*
+	 * default parameters
+	 */
+	param(samplingRate) = 44100;
+	paramStr(deviceName) = "audioio";
+	requestedFragmentSize = param(fragmentSize) = 4096;
+	requestedFragmentCount = param(fragmentCount) = 10;
+	audio_port=0;
+	audio_port1=0;
+	param(format)=17;
+	param(channels) = 2;
+	param(direction) = 2;
+}
+
+bool AudioIOSGI::open()
+{
+	string& _error = paramStr(lastError);
+	string& _deviceName = paramStr(deviceName);
+	int& _channels = param(channels);
+	int& _fragmentSize = param(fragmentSize);
+	int& _fragmentCount = param(fragmentCount);
+	int& _samplingRate = param(samplingRate);
+	int& _format = param(format);
+	int& _direction = param(direction);
+	int err;
+
+	if(_direction != 3  && _direction != 2){
+		_error = "invalid direction";
+		return false;
+	}
+	framesz=((_format & ~1) >> 3) * _channels;
+
+	audioconfig = alNewConfig();
+	alSetSampFmt(audioconfig,AL_SAMPFMT_TWOSCOMP);
+
+	alSetWidth(audioconfig, _format==8 ? AL_SAMPLE_8 : _format==16 || _format==17 ? AL_SAMPLE_16 : AL_SAMPLE_24);
+	alSetQueueSize(audioconfig,(requestedFragmentSize * requestedFragmentCount) / framesz);
+	alSetChannels(audioconfig,_channels);
+
+	audio_port = alOpenPort("out","w",audioconfig);
+
+
+	if (audio_port == (ALport) 0 ) {
+		err = oserror();
+		if (err == AL_BAD_NO_PORTS) {
+			_error = "System is out of audio ports";
+		} else if (err == AL_BAD_DEVICE_ACCESS) {
+			_error = "Couldn't access audio device";
+		} else if (err == AL_BAD_OUT_OF_MEM) {
+			_error = "Out of memory";
+		}
+		close();
+		return false;
+	}
+	if (_direction == 3){
+		audio_port1  = alOpenPort("in","r",audioconfig);
+		if (audio_port1 == (ALport) 0 ) {
+			err = oserror();
+			if (err == AL_BAD_NO_PORTS) {
+				_error = "System is out of audio ports";
+			} else if (err == AL_BAD_DEVICE_ACCESS) {
+				_error = "Couldn't access audio device";
+			} else if (err == AL_BAD_OUT_OF_MEM) {
+				_error = "Out of memory";
+			}
+			close();
+			return false;
+		}
+	}
+	/*
+	 * Attempt to set a crystal-based sample-rate on the
+	 * given device.
+	 */
+	ALpv x[2];
+	x[0].param = AL_MASTER_CLOCK;
+	x[0].value.i = AL_CRYSTAL_MCLK_TYPE;
+	x[1].param = AL_RATE;
+	x[1].value.ll = alDoubleToFixed(double(_samplingRate));
+	if (alSetParams(alGetResource(audio_port),x, 2)<0) {
+		_error="setparams failed: ";
+		_error+=alGetErrorString(oserror());
+		close();
+		return false;
+	}
+	if (_direction == 3)
+		if (alSetParams(alGetResource(audio_port1),x, 2)<0) {
+			_error="setparams failed: ";
+			_error+=alGetErrorString(oserror());
+			close();
+			return false;
+		}
+	if (x[1].sizeOut < 0) {
+		_error="rate was invalid";
+		close();
+		return false;
+	}
+
+	alSetFillPoint(audio_port,(alGetQueueSize(audioconfig)*5)/10) ;//50 %
+	if (_direction == 3)
+		alSetFillPoint(audio_port1,(alGetQueueSize(audioconfig)*4)/10) ;//40 %
+	/*
+	 * set the fragment settings to what the user requested
+	 */
+
+	_fragmentSize = requestedFragmentSize;
+	_fragmentCount = requestedFragmentCount;
+
+
+	artsdebug("buffering: %d fragments with %d bytes "
+		"(audio latency is %1.1f ms)", _fragmentCount, _fragmentSize,
+		(float)(_fragmentSize*_fragmentCount) /
+		(float)(2.0 * _samplingRate * _channels)*1000.0);
+
+
+	return true;
+}
+
+void AudioIOSGI::close()
+{
+	alFreeConfig(audioconfig);
+	alClosePort(audio_port);
+	audio_port=0;
+	if (param(direction) == 3) {
+		alClosePort(audio_port1);
+		audio_port1=0;
+	}
+}
+
+void AudioIOSGI::setParam(AudioParam p, int& value)
+{
+	switch(p)
+	{
+		case fragmentSize:
+				param(p) = requestedFragmentSize = value;
+			break;
+		case fragmentCount:
+				param(p) = requestedFragmentCount = value;
+			break;
+		default:
+				param(p) = value;
+			break;
+	}
+}
+
+int AudioIOSGI::getParam(AudioParam p)
+{
+	int frames;
+	switch(p)
+	{
+		case canRead:
+				frames=alGetFilled(audio_port);
+				return frames*framesz;
+			break;
+
+		case canWrite:
+				frames=alGetFillable(audio_port);
+				return frames*framesz;
+			break;
+
+		case selectReadFD:
+				return (param(direction) & directionRead)?
+						alGetFD(audio_port1):-1;
+			break;
+
+		case selectWriteFD:
+				return (param(direction) & directionWrite)?
+						alGetFD(audio_port):-1;
+			break;
+
+		default:
+				return param(p);
+			break;
+	}
+}
+
+int AudioIOSGI::read(void *buffer, int size)
+{
+	arts_assert(audio_port1 != 0);
+	::alReadFrames(audio_port1,buffer,size/framesz);
+	return size;
+}
+
+int AudioIOSGI::write(void *buffer, int size)
+{
+	arts_assert(audio_port != 0);
+	::alWriteFrames(audio_port,buffer,size/framesz);
+	return size;
+}
+
+#endif
diff --git a/flow/audioiosun.cc b/flow/audioiosun.cc
new file mode 100644
index 0000000..9b14aa4
--- /dev/null
+++ b/flow/audioiosun.cc
@@ -0,0 +1,442 @@
+    /*
+
+    Copyright (C) 2001 Aaron Williams
+                       aaronw@home.com
+	          (C) 2001 Stefan Westerfeld
+                       stefan@space.twc.de
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+/*
+ * Audio support for Sun Solaris, written by Aaron Williams
+ *
+ *
+ * Please send comments to aaronw@home.com
+ *
+ * This code has been tested with Solaris 7 running on a Sun Ultra 5
+ *
+ * Note that in Solaris the select support appears to be broken.
+ * Because of this, we use a timer and a dispatcher instead so we
+ * arn't polling (and sucking up most of the CPU).
+ *
+ * Currently read support has not been tested and will likely break
+ * other code
+ *
+ * 8-bit audio support also does not work (which I don't consider a 
+ * big deal).
+ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/*
+ * Only compile this AudioIO class if we're on Solaris
+ */
+#ifdef USE_SOLARIS
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#include <sys/audioio.h>
+#include <stropts.h>
+#include <sys/conf.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+
+#include "debug.h"
+#include "audioio.h"
+#include "audiosubsys.h"
+#include "iomanager.h"
+#include "dispatcher.h"
+
+// This looks like the maximum buffer size according to the sys/audio*.h 
+// files on Solaris7
+#define SUN_MAX_BUFFER_SIZE		(65536)
+
+namespace Arts {
+
+    class AudioIOSun : public AudioIO, public TimeNotify {
+    protected:
+		uint_t bytesRead, bytesWritten, bytesPerSec;
+		uint_t bytesPerSample;
+		timeval start;
+		int audio_fd;
+		int requestedFragmentSize;
+		int requestedFragmentCount;
+		audio_info_t auinfo;
+		
+#ifdef WORDS_BIGENDIAN
+		static const int defaultFormat = 17;
+#else
+		static const int defaultFormat = 16;
+#endif
+
+    public:
+		AudioIOSun();
+
+		// Timer callback
+		void notifyTime();
+
+		void setParam(AudioParam param, int& value);
+
+		int getParam(AudioParam param);
+
+		bool open();
+		void close();
+		int read(void *buffer, int size);
+		int write(void *buffer, int size);
+    };
+
+    REGISTER_AUDIO_IO(AudioIOSun,"sun","Sun Audio Input/Output");
+
+};
+
+using namespace std;
+using namespace Arts;
+
+AudioIOSun::AudioIOSun()
+{
+    /*
+     * default parameters
+     */
+    param(samplingRate) = 44100;
+	// solaris convention to support SunRays run out-of-the-box
+	const char *audioDev = getenv("AUDIODEV");
+    paramStr(deviceName) = (audioDev != 0)?audioDev:"/dev/audio";
+    param(fragmentSize) = 1024;
+    param(fragmentCount) = 7;
+    param(channels) = 2;
+    param(direction) = 2;
+    param(format) = defaultFormat;
+}
+
+// Opens the audio device
+bool AudioIOSun::open()
+{
+    string& _error = paramStr(lastError);
+    string& _deviceName = paramStr(deviceName);
+    int& _channels = param(channels);
+    int& _fragmentSize = param(fragmentSize);
+    int& _fragmentCount = param(fragmentCount);
+    int& _samplingRate = param(samplingRate);
+    int& _format = param(format);
+
+    int mode;
+
+    if (param(direction) == 3)
+		mode = O_RDWR;
+    else if (param(direction) == 2)
+		mode = O_WRONLY;
+    else
+    {
+		_error = "invalid direction";
+		return false;
+    }
+
+    audio_fd = ::open(_deviceName.c_str(), mode, 0);
+
+    if (audio_fd < 0)
+    {
+		_error = "device ";
+		_error += _deviceName.c_str();
+		_error += " can't be opened (";
+		_error += strerror(errno);
+		_error += ")";
+		return false;
+    }
+
+    fcntl(audio_fd, F_SETFL, O_NDELAY);
+
+    AUDIO_INITINFO(&auinfo);
+
+    if (ioctl(audio_fd, AUDIO_GETINFO, &auinfo) < 0)
+    {
+		_error = "device ";
+		_error += _deviceName.c_str();
+		_error += " AUDIO_GETINFO failed (";
+		_error += strerror(errno);
+		_error += ")";
+		return false;
+    }
+
+    if(_format != 8) _format = defaultFormat;
+#if 0
+    printf("param(direction)=%d\n", param(direction));
+    printf("format: %d\n", _format);
+    printf("channels: %d\n", _channels);		
+    printf("sampling rate: %d\n", _samplingRate);
+#endif
+
+    bytesPerSample = ((_format == 8) ? 8 : 16)/8 * _channels;
+
+    auinfo.play.precision = (_format == 8) ? 8 : 16;
+    if (param(direction) == 3)
+		auinfo.record.precision = (_format == 8) ? 8 : 16;
+
+    auinfo.play.encoding = AUDIO_ENCODING_LINEAR;
+    if (param(direction) == 3)
+		auinfo.record.encoding = AUDIO_ENCODING_LINEAR;
+
+    auinfo.play.channels = _channels;
+    if (param(direction) == 3)
+		auinfo.record.channels = _channels;
+
+    auinfo.play.sample_rate = _samplingRate;
+    if (param(direction) == 3)
+		auinfo.record.sample_rate = _samplingRate;
+
+    if (ioctl(audio_fd, AUDIO_SETINFO, &auinfo) < 0)
+    {
+		_error = "AUDIO_SETINFO failed - ";
+		_error += strerror(errno);
+
+		close();
+		return false;
+    }
+
+    
+    if (ioctl(audio_fd, AUDIO_GETINFO, &auinfo) < 0)
+    {
+		_error = "device ";
+		_error += _deviceName.c_str();
+		_error += " AUDIO_GETINFO failed (";
+		_error += strerror(errno);
+		_error += ")";
+		return false;
+    }
+
+    if (auinfo.play.precision != (uint_t)((_format == 8) ? 8 : 16) ||
+		(param(direction) == 3 && 
+		 auinfo.record.precision != (uint_t)((_format == 8) ? 8 : 16)))
+    {
+		char play_details[80];
+		char record_details[80];
+		sprintf(play_details, 
+				" (_format = %d, asked driver to give %d, got %d)",
+				_format, _format, auinfo.play.precision);
+		if (param(direction) == 3)
+		    sprintf(record_details, 
+				    " (_format = %d, asked driver to give %d, got %d)",
+				    _format, _format, auinfo.record.precision);
+
+		_error = "Can't set playback and/or record format  ";
+		_error += "Play format: ";
+		_error += play_details;
+		if (param(direction) == 3) {
+		    _error += "  Record format: ";
+		    _error += record_details;
+		}
+		close();
+		return false;
+    }
+    if ((auinfo.play.encoding != (uint_t)AUDIO_ENCODING_LINEAR) ||
+		(param(direction) == 3 &&
+		 auinfo.record.encoding != (uint_t)AUDIO_ENCODING_LINEAR))
+    {
+		char play_encoding[80], record_encoding[80];
+		sprintf(play_encoding, "(%d bits, %d encoding)",
+				auinfo.play.precision, auinfo.play.encoding);
+		sprintf(record_encoding, "(%d bits, %d encoding)",
+				auinfo.record.precision, auinfo.record.encoding);
+
+		_error = "Can't set playback and/or record format";
+		_error += "requested format was ";
+		_error += (_format == 8) ? "8-bit AUDIO_ENCODING_LINEAR" :
+		    "16-bit AUDIO_ENCODING_LINEAR";
+		_error += ", got playback format ";
+		_error += play_encoding;
+		if (param(direction) == 3) {
+		    _error += ", record format ";
+		    _error += record_encoding;
+		}
+
+		close();
+		return false;
+    }
+
+    if (auinfo.play.channels != (uint_t)_channels) {
+		_error = "Audio device doesn't support number of ";
+		_error += "requested playback channels";
+		close();
+		return false;
+    }
+    if (param(direction) == 3 && auinfo.record.channels != (uint_t)_channels) {
+		_error = "Audio device doesn't support number of ";
+		_error += "requested record channels";
+		close();
+		return false;
+    }
+
+    int tolerance = _samplingRate/10+1000;
+
+    if (abs(int(auinfo.play.sample_rate - _samplingRate)) > tolerance)
+    {
+		_error = "can't set requested playback sampling rate";
+
+		char details[80];
+		sprintf(details," (requested rate %d, got rate %d)",
+				_samplingRate, auinfo.play.sample_rate);
+		_error += details;
+
+		close();
+		return false;
+    }
+
+    if (param(direction) == 3 &&
+		abs(int(auinfo.record.sample_rate - _samplingRate)) > tolerance)
+    {
+		_error = "can't set requested record sampling rate";
+
+		char details[80];
+		sprintf(details," (requested rate %d, got rate %d)",
+				_samplingRate, auinfo.play.sample_rate);
+		_error += details;
+
+		close();
+		return false;
+    }
+
+
+    /*
+     * don't allow unreasonable large fragmentSize/Count combinations,
+     * because "real" hardware also doesn't
+     */
+
+    if(_fragmentSize > SUN_MAX_BUFFER_SIZE) 
+		_fragmentSize = SUN_MAX_BUFFER_SIZE;
+
+    while(_fragmentSize * _fragmentCount > SUN_MAX_BUFFER_SIZE)
+		_fragmentCount--;
+
+    bytesRead = bytesWritten = 0;
+    bytesPerSec = _channels * 2 * _samplingRate;
+
+    // Install the timer
+    Dispatcher::the()->ioManager()->addTimer(10, this);
+
+    gettimeofday(&start,0);
+
+    return true;
+}
+
+void AudioIOSun::close()
+{
+    ::close(audio_fd);
+    Dispatcher::the()->ioManager()->removeTimer(this);
+}
+
+// This is called on each timer tick
+void AudioIOSun::notifyTime()
+{
+    int& _direction = param(direction);
+    int& _fragmentSize = param(fragmentSize);
+
+    for (;;) {
+		int todo = 0;
+		if ((_direction & directionRead) && getParam(canRead) > _fragmentSize)
+		    todo |= AudioSubSystem::ioRead;
+
+		if ((_direction & directionWrite) && getParam(canWrite) > _fragmentSize)
+		    todo |= AudioSubSystem::ioWrite;
+
+		if (!todo)
+		    return;
+
+		AudioSubSystem::the()->handleIO(todo);
+    }
+}
+
+void AudioIOSun::setParam(AudioParam p, int& value)
+{
+    switch(p) {
+    case fragmentSize:
+		param(p) = requestedFragmentSize = value;
+		break;
+    case fragmentCount:
+		param(p) = requestedFragmentCount = value;
+		break;
+    default:
+		param(p) = value;
+		break;
+    }
+}
+
+int AudioIOSun::getParam(AudioParam p)
+{
+    int bytes;
+    int count;
+
+    switch(p)
+    {
+    case canRead:
+		if (ioctl(audio_fd, AUDIO_GETINFO, &auinfo) < 0)
+		    return (0);
+		bytes = (auinfo.record.samples * bytesPerSample) - bytesRead;
+		if (bytes < 0) {
+		    printf("Error: bytes %d < 0, samples=%u, bytesRead=%u\n",
+				   bytes, auinfo.record.samples, bytesRead);
+		    bytes = 0;
+		}
+		return bytes;
+
+    case canWrite:
+		if (ioctl(audio_fd, AUDIO_GETINFO, &auinfo) < 0) 
+		    return (0);
+		count = SUN_MAX_BUFFER_SIZE - 
+		    (bytesWritten - (auinfo.play.samples * bytesPerSample));
+		return count;
+
+	case autoDetect:
+		/*
+		 * If we're on Solaris, this driver is the one that will work,
+		 * and if we're not on Solaris, it won't be compiled anyway.
+		 */
+		return 12;
+
+    default:
+		return param(p);
+    }
+}
+
+int AudioIOSun::read(void *buffer, int size)
+{
+    size = ::read(audio_fd, buffer, size);
+    if (size < 0)
+		return 0;
+
+    bytesRead += size;
+    return size;
+}
+
+int AudioIOSun::write(void *buffer, int size)
+{
+    size = ::write(audio_fd, buffer, size);
+    bytesWritten += size;
+    return size;
+}
+
+#endif /* USE_SOLARIS */
diff --git a/flow/audiomanager_impl.cc b/flow/audiomanager_impl.cc
new file mode 100644
index 0000000..c2d2567
--- /dev/null
+++ b/flow/audiomanager_impl.cc
@@ -0,0 +1,325 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "flowsystem.h"
+#include "stdsynthmodule.h"
+#include "bus.h"
+
+using namespace Arts;
+using namespace std;
+
+namespace Arts {
+
+class AudioManagerClient_impl;
+
+class AudioManagerAssignable {
+public:
+	virtual long ID() = 0;
+	virtual void destination(const string& newDestination) = 0;
+};
+
+#ifdef __SUNPRO_CC
+/* Bloody SunPRO CC has problems with instantiation of the below two
+   templates, if the _clients and assignable member of AudioManager_impl
+   are declared to be directly the type list<xxx *>. So instead be move
+   a typedef in between, which makes it magically work.
+   We could also use an explicit instantiation, but this is not allowed
+   on all C++ compilers in this scope.  Note also, that we don't need
+   to replace _all_ occurrences of list<xxx*> below, only the two in the
+   member declaration.  What a mess.  */
+typedef list<AudioManagerClient_impl *> L_AMC;
+typedef list<AudioManagerAssignable *> L_AMA;
+#else
+/* with normal compilers there is no need for this typedef.  */
+#define L_AMC list<AudioManagerClient_impl *>
+#define L_AMA list<AudioManagerAssignable *>
+#endif
+
+class AudioManager_impl : virtual public AudioManager_skel
+{
+protected:
+	L_AMC _clients;
+	L_AMA assignable;
+	long _changes, nextID;
+	static AudioManager_impl *instance;
+public:
+	AudioManager_impl()
+	{
+		assert(!instance);
+		instance = this;
+		_changes = 0;
+		nextID = 1;
+	}
+	~AudioManager_impl()
+	{
+		assert(instance);
+		instance = 0;
+	}
+	vector<string> *destinations() { return BusManager::the()->busList(); }
+	long changes() { return _changes; }
+
+	vector<AudioManagerInfo> *clients();
+	void setDestination(long ID, const string& newDestination);
+	AudioManagerClient_impl *findClient(long ID);
+
+	// non MCOP interface
+	static AudioManager_impl *the() {
+		assert(instance);
+		return instance;
+	}
+	long addClient(AudioManagerClient_impl *client) {
+		_clients.push_back(client);
+		_changes++;
+		return nextID++;
+	}
+	void removeClient(AudioManagerClient_impl *client) {
+		_changes++;
+		_clients.remove(client);
+	}
+	void addAssignable(AudioManagerAssignable *a);
+	void removeAssignable(AudioManagerAssignable *a) {
+		assignable.remove(a);
+	}
+};
+
+AudioManager_impl *AudioManager_impl::instance = 0;
+
+class AudioManagerClient_impl :virtual public AudioManagerClient_skel
+{
+protected:
+	string _title, _autoRestoreID;
+	long _ID;
+	AudioManagerDirection _direction;
+	string _destination;
+
+public:
+	AudioManagerClient_impl() {
+		_ID = AudioManager_impl::the()->addClient(this);
+	}
+	~AudioManagerClient_impl() {
+		AudioManager_impl::the()->removeClient(this);
+	}
+
+	void title(const string& newvalue) { _title = newvalue; }
+	string title() { return _title; }
+
+	void autoRestoreID(const string& newvalue) { _autoRestoreID = newvalue; }
+	string autoRestoreID() { return _autoRestoreID; }
+
+	long ID() { return _ID; }
+
+    AudioManagerDirection direction() { return _direction; }
+	void direction(AudioManagerDirection newvalue) { _direction = newvalue; }
+
+	void constructor(AudioManagerDirection cdirection, const string& ctitle,
+					 const string& cautoRestoreID)
+	{
+		direction(cdirection);
+		title(ctitle);
+		autoRestoreID(cautoRestoreID);
+	}
+
+	/* non MCOP interface */
+	string destination() { return _destination; }
+	void destination(const string& newvalue) { _destination = newvalue; }
+};
+
+// this suffers a tiny bit from copypasting due to simpler
+// inheritance hierarchy
+class Synth_AMAN_PLAY_impl :virtual public Synth_AMAN_PLAY_skel,
+							virtual public AudioManagerAssignable,
+							virtual public StdSynthModule
+{
+protected:
+	Synth_BUS_UPLINK uplink;
+	AudioManagerClient client;
+public:
+	/* forward requests for title/autoRestoreID to client */
+	void title(const string& newvalue) { client.title(newvalue); }
+	string title() { return client.title(); }
+
+	void autoRestoreID(const string& newvalue) {client.autoRestoreID(newvalue);}
+	string autoRestoreID() { return client.autoRestoreID(); }
+
+	/* assign an already well-known client */
+	void constructor(AudioManagerClient client) {
+		this->client = client;
+		assert(client.direction() == amPlay);
+	}
+
+	Synth_AMAN_PLAY_impl() {
+		// Set direction of the client to amPlay, but actually it would
+		// be nice to do that only when we know we won't get a different client
+		// to use.
+		client.direction(amPlay);
+		_node()->virtualize("left",uplink._node(),"left");
+		_node()->virtualize("right",uplink._node(),"right");
+	}
+	void streamInit() {
+		AudioManager_impl::the()->addAssignable(this);
+		uplink.start();
+	}
+	void streamEnd() {
+		AudioManager_impl::the()->removeAssignable(this);
+		uplink.stop();
+	}
+	AutoSuspendState autoSuspend() {
+		return asSuspend;
+	}
+
+	// Assignable:
+	void destination(const string& destination) { uplink.busname(destination); }
+	long ID() { return client.ID(); }
+};
+
+// this suffers a tiny bit from copypasting due to simpler
+// inheritance hierarchy
+class Synth_AMAN_RECORD_impl :virtual public Synth_AMAN_RECORD_skel,
+							virtual public AudioManagerAssignable,
+							virtual public StdSynthModule
+{
+protected:
+	Synth_BUS_DOWNLINK downlink;
+	AudioManagerClient client;
+public:
+	/* forward requests for title/autoRestoreID to client */
+	void title(const string& newvalue) { client.title(newvalue); }
+	string title() { return client.title(); }
+
+	void autoRestoreID(const string& newvalue) {client.autoRestoreID(newvalue);}
+	string autoRestoreID() { return client.autoRestoreID(); }
+
+	/* assign an already well-known client */
+	void constructor(AudioManagerClient client) {
+		this->client = client;
+		assert(client.direction() == amRecord);
+	}
+
+	Synth_AMAN_RECORD_impl() {
+		// Set direction of the client to amRecord, but actually it would
+		// be nice to do that only when we know we won't get a different client
+		// to use.
+		client.direction(amRecord);
+		_node()->virtualize("left",downlink._node(),"left");
+		_node()->virtualize("right",downlink._node(),"right");
+	}
+
+	void streamInit() {
+		AudioManager_impl::the()->addAssignable(this);
+		downlink.start();
+	}
+	void streamEnd() {
+		AudioManager_impl::the()->removeAssignable(this);
+		downlink.stop();
+	}
+
+	// Assignable:
+	void destination(const string& destination){downlink.busname(destination);}
+	long ID() { return client.ID(); }
+};
+
+vector<AudioManagerInfo> *AudioManager_impl::clients()
+{
+	vector<AudioManagerInfo> *result = new vector<AudioManagerInfo>;
+	list<AudioManagerClient_impl *>::iterator i;
+
+	for(i = _clients.begin(); i != _clients.end(); i++)
+	{
+		AudioManagerClient_impl *client = *i;
+
+		AudioManagerInfo info;
+		info.ID = client->ID();
+		info.direction = client->direction();
+		info.title = client->title();
+		info.autoRestoreID = client->autoRestoreID();
+		info.destination = client->destination();
+
+		result->push_back(info);
+	}
+	return result;
+}
+
+
+AudioManagerClient_impl *AudioManager_impl::findClient(long ID)
+{
+	list<AudioManagerClient_impl *>::iterator i;
+
+	for(i = _clients.begin(); i != _clients.end(); i++)
+	{
+		AudioManagerClient_impl *client = *i;
+
+		if(client->ID() == ID)
+			return client;
+	}
+	return 0;
+}
+
+void AudioManager_impl::setDestination(long ID, const string& newDestination)
+{
+	AudioManagerClient_impl *client = findClient(ID);
+	if(client)
+	{
+		client->destination(newDestination);
+
+		list<AudioManagerAssignable *>::iterator i;
+		for(i = assignable.begin(); i != assignable.end(); i++)
+		{
+			AudioManagerAssignable *a = *i;
+			if(a->ID() == ID) a->destination(newDestination);
+		}
+		_changes++;
+	}
+}
+
+void AudioManager_impl::addAssignable(AudioManagerAssignable *a)
+{
+	// ensure that this client is assigned properly
+	AudioManagerClient_impl *client = findClient(a->ID());
+	assert(client);
+
+	if(client->destination().empty())
+	{
+		// TODO: more flexible default assignment policies - load autoRestoreID
+		// related stuff here (or somewhere else)
+
+		switch(client->direction())
+		{
+			case amPlay:	client->destination("out_soundcard");
+				break;
+			case amRecord:	client->destination("in_soundcard");
+				break;
+		}
+	}
+
+	assignable.push_back(a);
+	a->destination(client->destination());
+}
+
+REGISTER_IMPLEMENTATION(AudioManagerClient_impl);
+REGISTER_IMPLEMENTATION(AudioManager_impl);
+REGISTER_IMPLEMENTATION(Synth_AMAN_PLAY_impl);
+REGISTER_IMPLEMENTATION(Synth_AMAN_RECORD_impl);
+
+}
+
+// vim: sw=4 ts=4 noet
diff --git a/flow/audiosubsys.cc b/flow/audiosubsys.cc
new file mode 100644
index 0000000..a1238fc
--- /dev/null
+++ b/flow/audiosubsys.cc
@@ -0,0 +1,645 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>		// Needed on some systems.
+#endif
+
+#ifdef HAVE_SYS_SOUNDCARD_H
+#include <sys/soundcard.h>
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <iostream>
+#include <algorithm>
+#include <cstring>
+
+#include "debug.h"
+#include "audiosubsys.h"
+#include "audioio.h"
+
+#define DEFAULT_DEVICE_NAME "/dev/dsp"
+
+#undef DEBUG_WAVEFORM
+#ifdef DEBUG_WAVEFORM
+#include <fstream>
+#endif
+
+using namespace std;
+using namespace Arts;
+
+//--- automatic startup class
+
+static AudioSubSystemStart aStart;
+
+void AudioSubSystemStart::startup()
+{
+	_instance = new AudioSubSystem();
+}
+
+void AudioSubSystemStart::shutdown()
+{
+	delete _instance;
+}
+
+//--- AudioSubSystemPrivate data
+
+class Arts::AudioSubSystemPrivate
+{
+public:
+#ifdef DEBUG_WAVEFORM
+	ofstream plotfile;
+#endif
+	AudioIO *audioIO;
+	string audioIOName;
+	bool audioIOInit;
+
+	unsigned int adjustDuplexOffsetIndex;
+	int adjustDuplexOffset[4];
+	int adjustDuplexCount;
+};
+
+//--- AudioSubSystem implementation
+
+AudioSubSystem *AudioSubSystem::the()
+{
+	return aStart.the();
+}
+
+const char *AudioSubSystem::error()
+{
+	return _error.c_str();
+}
+
+AudioSubSystem::AudioSubSystem()
+{
+	d = new AudioSubSystemPrivate;
+#ifdef DEBUG_WAVEFORM
+	d->plotfile.open( "/dev/shm/audiosubsystem.plot" );
+#endif
+	d->audioIO = 0;
+	d->audioIOInit = false;
+
+	_running = false;
+	consumer = 0;
+	producer = 0;
+	fragment_buffer = 0;
+}
+
+AudioSubSystem::~AudioSubSystem()
+{
+	delete d->audioIO;
+	delete d;
+}
+
+bool AudioSubSystem::attachProducer(ASProducer *producer)
+{
+	assert(producer);
+	if(this->producer) return false;
+
+	this->producer = producer;
+	return true;
+}
+
+bool AudioSubSystem::attachConsumer(ASConsumer *consumer)
+{
+	assert(consumer);
+	if(this->consumer) return false;
+
+	this->consumer = consumer;
+	return true;
+}
+
+void AudioSubSystem::detachProducer()
+{
+	assert(producer);
+	producer = 0;
+
+	if(_running) close();
+}
+
+void AudioSubSystem::detachConsumer()
+{
+	assert(consumer);
+	consumer = 0;
+
+	if(_running) close();
+}
+
+/* initially creates default AudioIO */
+void AudioSubSystem::initAudioIO()
+{
+	/* auto detect */
+	if(!d->audioIOInit)
+	{
+		string bestName;
+		int bestValue = 0;
+
+		arts_debug("autodetecting driver: ");
+		for(int i = 0; i < AudioIO::queryAudioIOCount(); i++)
+		{
+			string name = AudioIO::queryAudioIOParamStr(i, AudioIO::name);
+			AudioIO *aio = AudioIO::createAudioIO(name.c_str());
+			int value = aio->getParam(AudioIO::autoDetect);
+
+			arts_debug(" - %s: %d", name.c_str(), value);
+			if(value > bestValue)
+			{
+				bestName = name;
+				bestValue = value;
+			}
+			delete aio;
+		}
+		if(bestValue)
+		{
+			arts_debug("... which means we'll default to %s", bestName.c_str());
+			audioIO(bestName);
+		}
+		else
+		{
+			arts_debug("... nothing we could use as default found");
+		}
+	}
+}
+
+void AudioSubSystem::audioIO(const string& audioIO)
+{
+	if(d->audioIO)
+		delete d->audioIO;
+
+	d->audioIOName = audioIO;
+	d->audioIO = AudioIO::createAudioIO(audioIO.c_str());
+	d->audioIOInit = true;
+}
+
+string AudioSubSystem::audioIO()
+{
+	initAudioIO();
+
+	return d->audioIOName;
+}
+
+void AudioSubSystem::deviceName(const string& deviceName)
+{
+	initAudioIO();
+	if(!d->audioIO) return;
+
+	d->audioIO->setParamStr(AudioIO::deviceName, deviceName.c_str());
+}
+
+string AudioSubSystem::deviceName()
+{
+	initAudioIO();
+	if(!d->audioIO) return "";
+
+	return d->audioIO->getParamStr(AudioIO::deviceName);
+}
+
+void AudioSubSystem::fragmentCount(int fragmentCount)
+{
+	initAudioIO();
+	if(!d->audioIO) return;
+
+	d->audioIO->setParam(AudioIO::fragmentCount, fragmentCount);
+}
+
+int AudioSubSystem::fragmentCount()
+{
+	initAudioIO();
+	if(!d->audioIO) return 0;
+
+	return d->audioIO->getParam(AudioIO::fragmentCount);
+}
+
+void AudioSubSystem::fragmentSize(int fragmentSize)
+{
+	initAudioIO();
+	if(!d->audioIO) return;
+
+	d->audioIO->setParam(AudioIO::fragmentSize, fragmentSize);
+}
+
+int AudioSubSystem::fragmentSize()
+{
+	initAudioIO();
+	if(!d->audioIO) return 0;
+
+	return d->audioIO->getParam(AudioIO::fragmentSize);
+}
+
+void AudioSubSystem::samplingRate(int samplingRate)
+{
+	initAudioIO();
+	if(!d->audioIO) return;
+
+	d->audioIO->setParam(AudioIO::samplingRate, samplingRate);
+}
+
+int AudioSubSystem::samplingRate()
+{
+	initAudioIO();
+	if(!d->audioIO) return 0;
+
+	return d->audioIO->getParam(AudioIO::samplingRate);
+}
+
+void AudioSubSystem::channels(int channels)
+{
+	initAudioIO();
+	if(!d->audioIO) return;
+
+	d->audioIO->setParam(AudioIO::channels, channels);
+}
+
+int AudioSubSystem::channels()
+{
+	initAudioIO();
+	if(!d->audioIO) return 0;
+
+	return d->audioIO->getParam(AudioIO::channels);
+}
+
+void AudioSubSystem::format(int format)
+{
+	initAudioIO();
+	if(!d->audioIO) return;
+
+	d->audioIO->setParam(AudioIO::format, format);
+}
+
+int AudioSubSystem::format()
+{
+	initAudioIO();
+	if(!d->audioIO) return 0;
+
+	return d->audioIO->getParam(AudioIO::format);
+}
+
+int AudioSubSystem::bits()
+{
+	int _format = format();
+	arts_assert(_format == 0 || _format == 8 || _format == 16 || _format == 17 || _format == 32);
+	return (_format & (32 | 16 | 8));
+}
+
+void AudioSubSystem::fullDuplex(bool fullDuplex)
+{
+	initAudioIO();
+	if(!d->audioIO) return;
+
+	int direction = fullDuplex?3:2;
+	d->audioIO->setParam(AudioIO::direction, direction);
+}
+
+bool AudioSubSystem::fullDuplex()
+{
+	initAudioIO();
+	if(!d->audioIO) return false;
+
+	return d->audioIO->getParam(AudioIO::direction) == 3;
+}
+
+int AudioSubSystem::selectReadFD()
+{
+	initAudioIO();
+	if(!d->audioIO) return false;
+
+	return d->audioIO->getParam(AudioIO::selectReadFD);
+}
+
+int AudioSubSystem::selectWriteFD()
+{
+	initAudioIO();
+	if(!d->audioIO) return false;
+
+	return d->audioIO->getParam(AudioIO::selectWriteFD);
+}
+
+bool AudioSubSystem::check()
+{
+        bool ok = open();
+
+	if(ok) close();
+	return ok;
+}
+
+bool AudioSubSystem::open()
+{
+	assert(!_running);
+
+	initAudioIO();
+	if(!d->audioIO)
+	{
+		if(d->audioIOName.empty())
+			_error = "couldn't auto detect which audio I/O method to use";
+		else
+			_error = "unable to select '"+d->audioIOName+"' style audio I/O";
+		return false;
+	}
+
+	if(d->audioIO->open())
+	{
+		_running = true;
+
+		_fragmentSize = d->audioIO->getParam(AudioIO::fragmentSize);
+		_fragmentCount = d->audioIO->getParam(AudioIO::fragmentCount);
+
+		// allocate global buffer to do I/O
+		assert(fragment_buffer == 0);
+		fragment_buffer = new char[_fragmentSize];
+
+		d->adjustDuplexCount = 0;
+		return true;
+	}
+	else
+	{
+		_error = d->audioIO->getParamStr(AudioIO::lastError);
+		return false;
+	}
+}
+
+void AudioSubSystem::close()
+{
+	assert(_running);
+	assert(d->audioIO);
+
+	d->audioIO->close();
+
+	wBuffer.clear();
+	rBuffer.clear();
+
+	_running = false;
+	if(fragment_buffer)
+	{
+		delete[] fragment_buffer;
+		fragment_buffer = 0;
+	}
+}
+
+bool AudioSubSystem::running()
+{
+	return _running;
+}
+
+void AudioSubSystem::handleIO(int type)
+{
+	assert(d->audioIO);
+
+	if(type & ioRead)
+	{
+		int len = d->audioIO->read(fragment_buffer,_fragmentSize);
+
+		if(len > 0)
+		{
+			if(rBuffer.size() < _fragmentSize * _fragmentCount * bits() / 8 * channels())
+			{
+				rBuffer.write(len,fragment_buffer);
+#ifdef DEBUG_WAVEFORM
+				float * end = (float *)(fragment_buffer + len);
+				float * floatbuffer = (float *)fragment_buffer;
+				while(floatbuffer < end)
+				{
+					d->plotfile << *floatbuffer++ << "\n";
+					++floatbuffer;
+				}
+#endif
+			}
+			else
+			{
+				arts_debug( "AudioSubSystem: rBuffer is too full" );
+			}
+		}
+	}
+
+	if(type & ioWrite)
+	{
+		/*
+		 * make sure that we have a fragment full of data at least
+		 */
+Rewrite:
+		while(wBuffer.size() < _fragmentSize)
+		{
+			long wbsz = wBuffer.size();
+			producer->needMore();
+
+			if(wbsz == wBuffer.size())
+			{
+				/*
+				 * Even though we asked the client to supply more
+				 * data, he didn't give us more. So we can't supply
+				 * output data as well. Bad luck. Might produce a
+				 * buffer underrun - but we can't help here.
+				 */
+				arts_info("full duplex: no more data available (underrun)");
+				return;
+			}
+		}
+
+		/*
+		 * look how much we really can write without blocking
+		 */
+		int space = d->audioIO->getParam(AudioIO::canWrite);
+		int can_write = min(space, _fragmentSize);
+
+		if(can_write > 0)
+		{
+			/*
+			 * ok, so write it (as we checked that our buffer has enough data
+			 * to do so and the soundcardbuffer has enough data to handle this
+			 * write, nothing can go wrong here)
+			 */
+			int rSize = wBuffer.read(can_write,fragment_buffer);
+			assert(rSize == can_write);
+
+			int len = d->audioIO->write(fragment_buffer,can_write);
+			if(len != can_write)
+				arts_fatal("AudioSubSystem::handleIO: write failed\n"
+				"len = %d, can_write = %d, errno = %d (%s)\n\n"
+				"This might be a sound hardware/driver specific problem"
+				" (see aRts FAQ)",len,can_write,errno,strerror(errno));
+
+			if(fullDuplex())
+			{
+				/*
+				 * if we're running full duplex, here is a good place to check
+				 * for full duplex drift
+				 */
+				d->adjustDuplexCount += can_write;
+				if(d->adjustDuplexCount > samplingRate())
+				{
+					adjustDuplexBuffers();
+					d->adjustDuplexCount = 0;
+				}
+			}
+		}
+
+                // If we can write a fragment more, then do so right now:
+                if (space >= _fragmentSize*2) goto Rewrite;
+	}
+
+	assert((type & ioExcept) == 0);
+}
+
+void AudioSubSystem::read(void *buffer, int size)
+{
+	/* if not enough data can be read, produce some */
+	while(rBuffer.size() < size)
+		adjustInputBuffer(1);
+
+	/* finally, just take the data out of the input buffer */
+	int rSize = rBuffer.read(size,buffer);
+	assert(rSize == size);
+}
+
+void AudioSubSystem::write(void *buffer, int size)
+{
+	wBuffer.write(size,buffer);
+}
+
+float AudioSubSystem::outputDelay()
+{
+	int fsize = _fragmentSize;
+	int fcount = _fragmentCount;
+
+	if(fsize > 0 && fcount > 0)	// not all AudioIO classes need to support this
+	{
+		double hardwareBuffer = fsize * fcount;
+		double freeOutputSpace = d->audioIO->getParam(AudioIO::canWrite);
+   		double playSpeed = channels() * samplingRate() * (bits() / 8);
+
+		return (hardwareBuffer - freeOutputSpace) / playSpeed;
+	}
+	else return 0.0;
+}
+
+void AudioSubSystem::adjustDuplexBuffers()
+{
+	int fsize = _fragmentSize;
+	int fcount = _fragmentCount;
+
+	if(fsize > 0 && fcount > 0)	// not all AudioIO classes need to support this
+	{
+		int bound = 2; //max(fcount/2, 1);
+		int optimalOffset = fsize * (fcount + bound);
+		int minOffset = fsize * fcount;
+		int maxOffset = fsize * (fcount + 2 * bound);
+
+		int canRead = d->audioIO->getParam(AudioIO::canRead);
+		if(canRead < 0)
+		{
+			arts_warning("AudioSubSystem::adjustDuplexBuffers: canRead < 0?");
+			canRead = 0;
+		}
+
+		int canWrite = d->audioIO->getParam(AudioIO::canWrite);
+		if(canWrite < 0)
+		{
+			arts_warning("AudioSubSystem::adjustDuplexBuffers: canWrite < 0?");
+			canWrite = 0;
+		}
+
+		int currentOffset = rBuffer.size() + wBuffer.size()
+                          + canRead + max((fsize * fcount) - canWrite, 0);
+
+		d->adjustDuplexOffset[d->adjustDuplexOffsetIndex++ & 3] = currentOffset;
+		if(d->adjustDuplexOffsetIndex <= 4) return;
+
+		int avgOffset;
+		avgOffset = d->adjustDuplexOffset[0]
+				  + d->adjustDuplexOffset[1]
+				  + d->adjustDuplexOffset[2]
+				  + d->adjustDuplexOffset[3];
+		avgOffset /= 4;
+
+		/*
+		printf("offset: %d   avg %d min %d opt %d max %d\r", currentOffset,
+				  avgOffset, minOffset, optimalOffset, maxOffset);
+		fflush(stdout);
+		*/
+		if(minOffset <= avgOffset && avgOffset <= maxOffset)
+			return;
+
+		d->adjustDuplexOffsetIndex = 0;
+		int adjust = (optimalOffset - currentOffset) / _fragmentSize;
+		arts_debug("AudioSubSystem::adjustDuplexBuffers(%d)", adjust);
+	}
+}
+
+void AudioSubSystem::adjustInputBuffer(int count)
+{
+	if(format() == 8)
+	{
+		memset( fragment_buffer, 0x80, _fragmentSize );
+	}
+	else
+	{
+		memset( fragment_buffer, 0, _fragmentSize );
+	}
+
+	while(count > 0 && rBuffer.size() < _fragmentSize * _fragmentCount * 4)
+	{
+		rBuffer.write(_fragmentSize, fragment_buffer);
+#ifdef DEBUG_WAVEFORM
+		float * end = (float *)(fragment_buffer + _fragmentSize);
+		float * floatbuffer = (float *)fragment_buffer;
+		while(floatbuffer < end)
+		{
+			d->plotfile << *floatbuffer++ << "\n";
+			++floatbuffer;
+		}
+#endif
+		count--;
+	}
+
+	while(count < 0 && rBuffer.size() >= _fragmentSize)
+	{
+		rBuffer.read(_fragmentSize, fragment_buffer);
+		count++;
+	}
+}
+
+void AudioSubSystem::emergencyCleanup()
+{
+	if(producer || consumer)
+	{
+		fprintf(stderr, "AudioSubSystem::emergencyCleanup\n");
+
+		if(producer)
+			detachProducer();
+		if(consumer)
+			detachConsumer();
+	}
+}
diff --git a/flow/audiosubsys.h b/flow/audiosubsys.h
new file mode 100644
index 0000000..ede38c2
--- /dev/null
+++ b/flow/audiosubsys.h
@@ -0,0 +1,236 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef AUDIOSUBSYS_H
+#define AUDIOSUBSYS_H
+#include <string>
+
+#include "arts_export.h"
+#include "pipebuffer.h"
+#include "startupmanager.h"
+
+/*
+ * BC - Status (2002-03-08): AudioSubSystem, ASProducer, ASConsumer.
+ *
+ * These classes are kept binary compatible. You can rely on them.
+ * AudioSubSystem has a private data pointer to do so. Even if ports to
+ * other architectures or hardware will require different organization
+ * (i.e. no fragments, direct memory access via mmap), the data members
+ * and functions exported here MAY NOT BE CHANGED. Use the private data
+ * pointer for adding data members.
+ *
+ * If ASProducer/ASConsumer doesn't suit the needs any longer, do NOT
+ * change them. Add new classes instead.
+ */
+
+namespace Arts {
+
+class ASProducer {
+public:
+	virtual void needMore() = 0;
+};
+
+// FIXME: haveMore won't be called currently
+class ASConsumer {
+public:
+	virtual void haveMore() = 0;
+};
+
+class ARTS_EXPORT AudioSubSystemStart :public StartupClass {
+protected:
+	class AudioSubSystem *_instance;
+public:
+	inline AudioSubSystem *the() { return _instance; };
+	void startup();
+	void shutdown();
+};
+
+class AudioSubSystemPrivate;
+
+class ARTS_EXPORT AudioSubSystem {
+	class AudioSubSystemPrivate *d;
+
+	std::string _error;
+	char *fragment_buffer;
+
+	int _fragmentCount;
+	int _fragmentSize;
+
+	bool _running;
+	PipeBuffer wBuffer, rBuffer;
+	ASConsumer *consumer;
+	ASProducer *producer;
+
+	friend class AudioSubSystemStart;
+	AudioSubSystem();
+	~AudioSubSystem();
+
+	void close();
+	void initAudioIO();
+
+	/**
+	 * checks that full duplex doesn't go out of sync
+	 */
+	void adjustDuplexBuffers();
+
+	/**
+	 * creates count empty fragments of input in rBuffer if count > 0
+	 * removes count fragments of input from rBuffer if count < 0
+	 */
+	void adjustInputBuffer(int count);
+
+public:
+	enum { ioRead=1, ioWrite=2, ioExcept=4 };
+
+	// singleton
+	static AudioSubSystem *the();
+
+	/*
+	 * Currently, if you want to use the AudioSubSystem, you need to
+	 * 
+	 * 1. - attach one producer
+	 *    - attach one consumer (only for full duplex)
+	 *    - open the audio subsystem using open (watch the fd)
+	 *    (in any order)
+	 *
+	 * 2. react on the callbacks you get for the producer
+	 *
+	 * 3. if you don't need the audio subsystem any longer, call detach
+	 *    both, the producer and the cosumer.
+	 *
+	 * Be careful that you don't read/write from/to the audio subsystem
+	 * when running() is not true.
+	 */
+
+	bool attachProducer(ASProducer *producer);
+	bool attachConsumer(ASConsumer *consumer);
+
+	void detachProducer();
+	void detachConsumer();
+
+	/*
+	 * can be used to select the AudioIO class to use, reasonable choices
+	 * may be "oss" or "alsa" at this point in time - you need to choose
+	 * this before doing anything else
+	 */
+	void audioIO(const std::string& audioIO);
+	std::string audioIO();
+
+	// which device to use for audio output (default /dev/dsp)
+	void deviceName(const std::string& deviceName);
+	std::string deviceName();
+
+	void fragmentSize(int size);
+	int fragmentSize();
+
+	void fragmentCount(int fragments);
+	int fragmentCount();
+
+	void samplingRate(int samplingrate);
+	int samplingRate();
+
+	void channels(int channels);
+	int channels();
+
+	void format(int format);
+	int format();
+
+	/**
+	 * As opposed to format(), this one returns the number of bits used per
+	 * sample. Thats sometimes a difference, for instance 16bit big endian
+	 * encoding has the format() 17, whereas bits() would return 16.
+	 */
+	int bits();
+
+	void fullDuplex(bool newFullDuplex);
+	bool fullDuplex();
+
+	bool check();
+
+	/**
+	 * Opens the audio device.
+	 *
+	 * After opening, you must check selectReadFD() and selectWriteFD() to
+	 * select() on the appropriate file descriptors. Whenever select()ing is
+	 * successful, handleIO needs to be called.
+	 *
+	 * The type for handleIO must be set to ioRead if fd is ready for
+	 * reading, ioWrite if fd is ready for writing, ioExcept if something
+	 * special happend or any combination of these using bitwise or.
+	 *
+	 * @returns true if audio device has been opened successfully,
+	 *          false otherwise
+	 */
+	bool open();
+
+	/**
+	 * human readable error message that descibes why opening the audio device
+	 * failed
+	 */
+	const char *error();
+
+	/**
+	 * File descriptor to select on for reading (@see open()), -1 if there is
+	 * none.
+	 */
+	int selectReadFD();
+
+	/**
+	 * File descriptor to select on for writing (@see open()), -1 if there is
+	 * none.
+	 */
+	int selectWriteFD();
+
+	/**
+	 * Needs to be called to handle I/O on the filedescriptors given by
+	 * selectReadFD() and selectWriteFD() (@see open()).
+	 */
+	void handleIO(int type);
+
+	void read(void *buffer, int size);
+	void write(void *buffer, int size);
+
+	/**
+	 * this returns the time in seconds it will take until everything written
+	 * to the AudioSubSystem so far will be played - in other words, it returns
+	 * the time it will take until the next sample written by the application
+	 * will be heard by the user
+	 */
+	float outputDelay();
+
+	/**
+	 * returns true as long as the audio subsystem is opened and active (that
+	 * is, between successful opening, with attaching producer, and the first
+	 * detachConsumer/detachProducer)
+	 */
+	bool running();
+
+	/**
+	 * called during crashes, to release the opened device (and other resources)
+	 * don't use this method for other purposes than emergencies
+	 */
+	void emergencyCleanup();
+};
+
+}
+
+#endif /* AUDIOSUBSYS_H */
diff --git a/flow/audiotobytestream_impl.cc b/flow/audiotobytestream_impl.cc
new file mode 100644
index 0000000..866b85a
--- /dev/null
+++ b/flow/audiotobytestream_impl.cc
@@ -0,0 +1,223 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+                  2001, 2003 Matthias Kretz
+                             kretz@kde.org
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+#include "debug.h"
+
+#include <vector>
+#include <iostream>
+#include <math.h>
+
+#undef DEBUG_MESSAGES
+
+using namespace std;
+using namespace Arts;
+
+namespace Arts {
+
+class AudioToByteStream_impl : public AudioToByteStream_skel,
+                               public StdSynthModule
+{
+	long _samplingRate, _channels, _bits;
+	long sampleSize;
+	double step;
+	bool interpolate;
+	vector<float> leftbuffer;
+	vector<float> rightbuffer;
+	int range;
+	double _pos;
+protected:
+	void updateSampleSize()
+	{
+		sampleSize = _channels * _bits / 8;
+	}
+
+public:
+	AudioToByteStream_impl() :
+		_pos(0)
+	{
+		samplingRate(44100);
+		channels(2);
+		bits(16);
+	}
+
+	long samplingRate() { return _samplingRate; }
+	void samplingRate(long newRate) {
+		double newStep = samplingRateFloat / (float)newRate;
+		arts_return_if_fail(newStep > 0);
+		_samplingRate = newRate;
+		step = newStep;
+
+		double delta = step - floor(step);
+		interpolate = fabs(delta) > 0.001;
+#ifdef DEBUG_MESSAGES
+		arts_debug( "samplingRate(%i): step = %e, delta = %e, interpolate: %i", newRate, step, delta, interpolate );
+#endif
+	}
+
+	long channels() { return _channels; }
+	void channels(long newChannels) {
+		arts_return_if_fail(newChannels == 1 || newChannels == 2);
+		_channels = newChannels;
+		updateSampleSize();
+	}
+
+	long bits() { return _bits; }
+	void bits(long newBits) {
+		arts_return_if_fail(newBits == 8 || newBits == 16);
+		_bits = newBits;
+		range = (newBits == 8 ) ? 128 : 32768;
+		updateSampleSize();
+	}
+
+	void calculateBlock(unsigned long samples)
+	{
+		leftbuffer.resize( 1 + samples );
+		rightbuffer.resize( 1 + samples );
+		for( unsigned long i = 0; i < samples; ++i ) {
+			leftbuffer[1 + i] = (left[i] > 1.0f) ? 1.0f : (left[i] < -1.0f) ? -1.0f : left[i];
+			rightbuffer[1 + i] = (right[i] > 1.0f) ? 1.0f : (right[i] < -1.0f) ? -1.0f : right[i];
+		}
+
+		int samplestosend = (int)ceil(leftbuffer.size() / step);
+		DataPacket<mcopbyte> *packet = outdata.allocPacket( samplestosend * sampleSize );
+#ifdef DEBUG_MESSAGES
+		arts_debug( "calculateBlock(%i): send %i samples", samples, samplestosend );
+#endif
+
+		int processed = 0;
+		if( interpolate ) {
+			double pos = 0;
+			if( _channels == 2 ) {
+				if( _bits == 16 ) {
+					while( _pos < (double)leftbuffer.size() - 1 ) {
+						double error = modf(_pos, &pos);
+						int intpos = (int)pos;
+#ifdef DEBUG_MESSAGES
+						arts_debug( "pos=%i, error=%e", intpos, error );
+#endif
+						long leftchannel = long((leftbuffer[intpos] * (1.0 - error) + leftbuffer[intpos + 1] * error) * 32768) + 32768;
+						long rightchannel = long((rightbuffer[intpos] * (1.0 - error) + rightbuffer[intpos + 1] * error) * 32768) + 32768;
+						packet->contents[processed    ] = leftchannel;
+						packet->contents[processed + 1] = (leftchannel >> 8) - 128;
+						packet->contents[processed + 2] = rightchannel;
+						packet->contents[processed + 3] = (rightchannel >> 8) - 128;
+						_pos += step;
+						processed += 4;
+					}
+				} else if( _bits == 8 ) {
+					while( _pos < (double)leftbuffer.size() - 1 ) {
+						double error = modf(_pos, &pos);
+						int intpos = (int)pos;
+						long leftchannel = long((leftbuffer[intpos] * (1.0 - error) + leftbuffer[intpos + 1] * error) * 128) + 128;
+						long rightchannel = long((rightbuffer[intpos] * (1.0 - error) + rightbuffer[intpos + 1] * error) * 128) + 128;
+						packet->contents[processed    ] = leftchannel;
+						packet->contents[processed + 1] = rightchannel;
+						_pos += step;
+						processed += 2;
+					}
+				}
+			} else {
+				if( _bits == 16 ) {
+					while( _pos < (double)leftbuffer.size() - 1 ) {
+						double error = modf(_pos, &pos);
+						int intpos = (int)pos;
+						long leftchannel = long(((leftbuffer[intpos] + rightbuffer[intpos]) * (1.0 - error) + (leftbuffer[intpos + 1] + rightbuffer[intpos + 1]) * error) * 16384) + 32768;
+						packet->contents[processed    ] = leftchannel;
+						packet->contents[processed + 1] = (leftchannel >> 8) - 128;
+						_pos += step;
+						processed += 2;
+					}
+				} else if( _bits == 8 ) {
+					while( _pos < (double)leftbuffer.size() - 1 ) {
+						double error = modf(_pos, &pos);
+						int intpos = (int)pos;
+						long leftchannel = long(((leftbuffer[intpos] + rightbuffer[intpos]) * (1.0 - error) + (leftbuffer[intpos + 1] + rightbuffer[intpos + 1]) * error) * 64) + 128;
+						packet->contents[processed] = leftchannel;
+						_pos += step;
+						++processed;
+					}
+				}
+			}
+		} else {
+			if( _channels == 2 ) {
+				if( _bits == 16 ) {
+					while( _pos < (double)leftbuffer.size() - 1 ) {
+						int intpos = (int)_pos;
+						long leftchannel = long(leftbuffer[intpos] * 32768) + 32768;
+						long rightchannel = long(rightbuffer[intpos] * 32768) + 32768;
+						packet->contents[processed    ] = leftchannel;
+						packet->contents[processed + 1] = (leftchannel >> 8) - 128;
+						packet->contents[processed + 2] = rightchannel;
+						packet->contents[processed + 3] = (rightchannel >> 8) - 128;
+						_pos += step;
+						processed += 4;
+					}
+				} else if( _bits == 8 ) {
+					while( _pos < (double)leftbuffer.size() - 1 ) {
+						int intpos = (int)_pos;
+						long leftchannel = long(leftbuffer[intpos] * 128) + 128;
+						long rightchannel = long(rightbuffer[intpos] * 128) + 128;
+						packet->contents[processed    ] = leftchannel;
+						packet->contents[processed + 1] = rightchannel;
+						_pos += step;
+						processed += 2;
+					}
+				}
+			} else {
+				if( _bits == 16 ) {
+					while( _pos < (double)leftbuffer.size() - 1 ) {
+						int intpos = (int)_pos;
+						long leftchannel = long((leftbuffer[intpos] + rightbuffer[intpos]) * 16384) + 32768;
+						packet->contents[processed    ] = leftchannel;
+						packet->contents[processed + 1] = (leftchannel >> 8) - 128;
+						_pos += step;
+						processed += 2;
+					}
+				} else if( _bits == 8 ) {
+					while( _pos < (double)leftbuffer.size() - 1 ) {
+						int intpos = (int)_pos;
+						long leftchannel = long((leftbuffer[intpos] + rightbuffer[intpos]) * 64) + 128;
+						packet->contents[processed] = leftchannel;
+						_pos += step;
+						++processed;
+					}
+				}
+			}
+		}
+		leftbuffer[0] = leftbuffer.back();
+		rightbuffer[0] = rightbuffer.back();
+		_pos = _pos - floor(_pos);
+		packet->size = processed;
+		packet->send();
+#ifdef DEBUG_MESSAGES
+		arts_debug( "calculateBlock(%i): %i samples sent, _pos = %e", samples, processed / sampleSize, _pos );
+#endif
+	}
+};
+
+REGISTER_IMPLEMENTATION(AudioToByteStream_impl);
+
+}
diff --git a/flow/bufferqueue.h b/flow/bufferqueue.h
new file mode 100644
index 0000000..5344c4a
--- /dev/null
+++ b/flow/bufferqueue.h
@@ -0,0 +1,148 @@
+/*
+ * BC - Status (2002-03-08): ByteBuffer, BufferQueue
+ *
+ * None of these classes is considered part of the public API. Do NOT use it
+ * in your apps. These are part of the implementation of libartsflow's
+ * AudioSubSystem, and subject to change/disappearing due to optimization
+ * work.
+ */
+
+#ifndef _BUFFERQUEUE_H
+#define _BUFFERQUEUE_H
+
+#include "thread.h"
+
+#define _DEFAULT_CHUNK_SIZE 4096
+#define _MAX_CHUNKS 3
+
+namespace Arts
+{
+
+class ByteBuffer
+{
+	unsigned char* content;
+	int _size;
+	int _maxSize;
+	int rp;
+
+public:
+	ByteBuffer() {
+		_size = rp = 0;
+		_maxSize = _DEFAULT_CHUNK_SIZE;
+		content = new unsigned char[_DEFAULT_CHUNK_SIZE];
+	}
+	ByteBuffer(const void* s, int len) {
+		_maxSize = _DEFAULT_CHUNK_SIZE;
+		content = new unsigned char[_DEFAULT_CHUNK_SIZE];
+		put(s, len);
+	}
+
+	~ByteBuffer() { delete [] content; }
+
+	void put(const void* s, int len) {
+		if ((_size = len) != 0)
+			memcpy(content, s, len);
+		rp = 0;
+	}
+
+	void* get()          { return content+rp; }
+	void* reset()        { _size = 0; rp = 0; return content; }
+	int push(int len)    { _size -= len; rp += len; return _size; }
+	void set(int len)    { _size = len; rp = 0; }
+	int size() const     { return _size; }
+	int maxSize() const  { return _maxSize; }
+
+	void setMaxSize(int size) {
+		delete [] content;
+		content = new unsigned char[size];
+		_maxSize = size;
+	}
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class BufferQueue
+{
+private:
+	ByteBuffer bufs[_MAX_CHUNKS];
+	int rp;
+	int wp;
+	Arts::Semaphore* sema_produced;
+	Arts::Semaphore* sema_consumed;
+
+	void semaReinit() {
+		delete sema_consumed;
+		delete sema_produced;
+		sema_consumed = new Arts::Semaphore(0, _MAX_CHUNKS);
+		sema_produced = new Arts::Semaphore(0, 0);
+	}
+
+
+public:
+	BufferQueue() {
+		rp = wp = 0;
+		sema_consumed = new Arts::Semaphore(0, _MAX_CHUNKS);
+		sema_produced = new Arts::Semaphore(0, 0);
+	}
+
+	~BufferQueue() {
+		delete sema_consumed;
+		delete sema_produced;
+	}
+
+	void write(void* data, int len);
+	ByteBuffer* waitConsumed();
+	void produced();
+
+	ByteBuffer* waitProduced();
+	void consumed();
+
+	bool isEmpty() const       { return sema_produced->getValue() == 0; }
+	int bufferedChunks() const { return sema_produced->getValue(); }
+	int freeChunks() const     { return sema_consumed->getValue(); }
+	int maxChunks() const      { return _MAX_CHUNKS; }
+	int chunkSize() const      { return bufs[0].maxSize(); }
+	void clear()               { rp = wp = 0; semaReinit(); }
+	void setChunkSize(int size){
+		for (int i=0; i < maxChunks(); i++)
+			bufs[i].setMaxSize(size);
+	}
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+inline void BufferQueue::write(void* data, int len)
+{
+	sema_consumed->wait();
+	bufs[wp].put(data, len);
+	++wp %= _MAX_CHUNKS;
+	sema_produced->post();
+}
+
+inline ByteBuffer* BufferQueue::waitConsumed()
+{
+	sema_consumed->wait();
+	return &bufs[wp];
+}
+
+inline void BufferQueue::produced()
+{
+	++wp %= _MAX_CHUNKS;
+	sema_produced->post();
+}
+
+inline ByteBuffer* BufferQueue::waitProduced()
+{
+	sema_produced->wait();
+	return &bufs[rp];
+}
+
+inline void BufferQueue::consumed()
+{
+	++rp %=_MAX_CHUNKS;
+	sema_consumed->post();
+}
+
+}
+
+#endif
diff --git a/flow/bus.cc b/flow/bus.cc
new file mode 100644
index 0000000..ba5e778
--- /dev/null
+++ b/flow/bus.cc
@@ -0,0 +1,367 @@
+    /*
+
+    Copyright (C) 1998-2000 Stefan Westerfeld
+                            stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "bus.h"
+#include "flowsystem.h"
+#include "debug.h"
+#include <iostream>
+#include <set>
+
+#ifdef __SUNPRO_CC
+/* SunPRO CC looses to link this when the_BusManager is static, because
+   later a template implementation file references this symbol. */
+#define the_BusManager __internal_aRts_the_BusManager__Bahh__
+#else
+static
+#endif
+  Arts::BusManager *the_BusManager = 0;
+
+using namespace Arts;
+using namespace std;
+
+// shutdown bus manager on termination
+
+namespace Arts {
+	static class BusManagerShutdown :public StartupClass
+	{
+	public:
+		void startup() { };
+		void shutdown()
+		{
+			if(::the_BusManager)
+			{
+				delete ::the_BusManager;
+				::the_BusManager = 0;
+			}
+		}
+	}	The_BusManagerShutdown;
+}
+
+BusManager::BusManager()
+{
+	// this constructor isn't public (Singleton)
+}
+
+BusManager *BusManager::the()
+{
+	if(!::the_BusManager) ::the_BusManager = new BusManager;
+	return(::the_BusManager);
+}
+
+BusManager::Bus *BusManager::findBus(const string& name)
+{
+	list<Bus *>::iterator bi;
+
+	for(bi = _busList.begin(); bi != _busList.end(); bi++)
+	{
+		if((*bi)->name == name) return(*bi);
+	}
+	Bus *bus = new Bus;
+	bus->left.start();
+	bus->right.start();
+	bus->name = name;
+	_busList.push_back(bus);
+
+	return(bus);
+}
+
+vector<string> *BusManager::busList()
+{
+	set<string> names;
+	set<string>::iterator si;
+	
+	list<Bus *>::iterator bi;
+	for(bi = _busList.begin(); bi != _busList.end(); bi++)
+		names.insert((*bi)->name);
+
+	vector<string> *bl = new vector<string>;
+	for(si=names.begin();si != names.end();si++) bl->push_back(*si);
+	return bl; 
+}
+
+void BusManager::addClient(const string& busname, BusClient *client)
+{
+	Bus *bus = findBus(busname);
+	bus->clients.push_back(client);
+
+	// attach the new client
+	client->snode()->virtualize("left", bus->left._node(), "invalue");
+	client->snode()->virtualize("right", bus->right._node(), "invalue");
+}
+
+void BusManager::removeClient(BusClient *client)
+{
+	list<Bus *>::iterator bi;
+	for(bi = _busList.begin(); bi != _busList.end(); bi++)
+	{
+		Bus *bus = *bi;
+
+		list<BusClient *>::iterator ci;
+		for(ci = bus->clients.begin(); ci != bus->clients.end(); ci++)
+		{
+			if(*ci == client)
+			{
+				bus->clients.erase(ci);
+
+				if(bus->clients.empty() && bus->servers.empty())
+				{
+					_busList.erase(bi);
+					delete bus;
+				}
+				else
+				{
+					client->snode()->devirtualize("left",
+							bus->left._node(), "invalue");
+					client->snode()->devirtualize("right",
+							bus->right._node(), "invalue");
+				}
+				return;
+			}
+		}
+	}
+}
+
+void BusManager::addServer(const string& busname, BusClient *server)
+{
+	Bus *bus = findBus(busname);
+	bus->servers.push_back(server);
+
+	server->snode()->virtualize("left",bus->left._node(),"outvalue");
+	server->snode()->virtualize("right",bus->right._node(),"outvalue");
+}
+
+void BusManager::removeServer(BusClient *server)
+{
+	list<Bus *>::iterator bi;
+	
+	for(bi = _busList.begin(); bi != _busList.end(); bi++)
+	{
+		Bus *bus = *bi;
+
+		list<BusClient *>::iterator si;
+		for(si = bus->servers.begin(); si != bus->servers.end(); si++)
+		{
+			if(*si == server)
+			{
+				bus->servers.erase(si);
+				if(bus->clients.empty() && bus->servers.empty())
+				{
+					_busList.erase(bi);
+					delete bus;
+				}
+				else
+				{
+					server->snode()->devirtualize("left",
+									bus->left._node(), "outvalue");
+					server->snode()->devirtualize("right",
+									bus->right._node(),"outvalue");
+				}
+				return;
+			}
+		}
+	}
+}
+
+namespace Arts {
+
+class Synth_BUS_UPLINK_impl :public Synth_BUS_UPLINK_skel,
+										public StdSynthModule, public BusClient
+{
+	BusManager *bm;
+	bool running, active, relink;
+	string _busname;
+public:
+	Synth_BUS_UPLINK_impl();
+
+	string busname() { return _busname; }
+	void busname(const string& newname);
+	AutoSuspendState autoSuspend() { return asSuspend; }
+	void streamInit();
+	void streamEnd();
+	ScheduleNode *snode() { return _node(); }
+
+	void CallBack();
+
+	void connect();
+	void disconnect();
+};
+
+REGISTER_IMPLEMENTATION(Synth_BUS_UPLINK_impl);
+
+}
+
+Synth_BUS_UPLINK_impl::Synth_BUS_UPLINK_impl() :running(false)
+{
+	bm = BusManager::the();
+}
+
+void Synth_BUS_UPLINK_impl::streamInit()
+{
+	assert(!running);
+	running = true;
+	active = relink = false;
+
+	connect();	// connect to the BusManager
+}
+
+void Synth_BUS_UPLINK_impl::busname(const string& newname)
+{
+	_busname = newname;
+
+	/* TODO */
+	// to be sure that reconnection happens when outside the scheduling cycle
+	if(running)
+	{
+		relink = true;
+		CallBack();
+	}
+}
+
+void Synth_BUS_UPLINK_impl::connect()
+{
+	assert(active == false);
+	if(!_busname.empty())
+	{
+		active = true;
+		bm->addClient(_busname, this);
+	}
+}
+
+void Synth_BUS_UPLINK_impl::disconnect()
+{
+	if(active == true)
+	{
+		bm->removeClient(this);
+		active = false;
+	}
+}
+
+void Synth_BUS_UPLINK_impl::CallBack()
+{
+	if(relink)
+	{
+		disconnect();
+		connect();
+		relink = false;
+	}
+}
+
+void Synth_BUS_UPLINK_impl::streamEnd()
+{
+	disconnect();
+
+	assert(running);
+	running = false;
+}
+
+namespace Arts {
+
+class Synth_BUS_DOWNLINK_impl :public Synth_BUS_DOWNLINK_skel,
+										public StdSynthModule, public BusClient
+{
+	bool running, active, relink;
+	BusManager *bm;
+
+	string _busname;
+
+	void connect();
+	void disconnect();
+
+public:
+	string busname() { return _busname; }
+	void busname(const string& newname);
+
+	Synth_BUS_DOWNLINK_impl();
+	AutoSuspendState autoSuspend() { return asSuspend; }
+	void streamInit();
+	void streamEnd();
+	void CallBack();
+	ScheduleNode *snode() { return _node(); }
+};
+
+REGISTER_IMPLEMENTATION(Synth_BUS_DOWNLINK_impl);
+
+}
+
+Synth_BUS_DOWNLINK_impl::Synth_BUS_DOWNLINK_impl() :running(false)
+{
+	bm = BusManager::the();
+}
+
+void Synth_BUS_DOWNLINK_impl::streamInit()
+{
+	assert(!running);
+	running = true;
+
+	active = relink = false;
+	connect();
+}
+
+void Synth_BUS_DOWNLINK_impl::streamEnd()
+{
+	assert(running);
+	running = false;
+
+	disconnect();
+}
+
+void Synth_BUS_DOWNLINK_impl::connect()
+{
+	assert(active == false);
+	if(!_busname.empty())
+	{
+		active = true;
+		bm->addServer(_busname, this);
+	}
+}
+
+void Synth_BUS_DOWNLINK_impl::disconnect()
+{
+	if(active == true)
+	{
+		bm->removeServer(this);
+		active = false;
+	}
+}
+
+void Synth_BUS_DOWNLINK_impl::CallBack()
+{
+	if(relink)
+	{
+		disconnect();
+		connect();
+		relink = false;
+	}
+}
+
+void Synth_BUS_DOWNLINK_impl::busname(const string& newname)
+{
+	_busname = newname;
+
+	/* TODO */
+	// to be sure that reconnection happens when outside the scheduling cycle
+	if(running)
+	{
+		relink = true;
+		CallBack();
+	}
+}
diff --git a/flow/bus.h b/flow/bus.h
new file mode 100644
index 0000000..747932b
--- /dev/null
+++ b/flow/bus.h
@@ -0,0 +1,76 @@
+    /*
+
+    Copyright (C) 1998-2000 Stefan Westerfeld
+                            stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef ARTS_BUS_H
+#define ARTS_BUS_H
+
+#include "stdsynthmodule.h"
+#include "artsflow.h"
+
+/*
+ * BC - Status (2002-03-08): BusClient, BusManager
+ *
+ * None of these classes is considered part of the public API. Do NOT use it
+ * in your apps. These are part of the implementation of libartsflow's
+ * Synth_BUS_* and Synth_AMAN_* and AudioManager interfaces. Use these for
+ * public use instead, and don't touch this here.
+ */
+
+
+namespace Arts {
+
+class BusClient
+{
+public:
+	virtual Arts::ScheduleNode *snode() = 0;
+};
+
+
+class BusManager
+{
+protected:
+	struct Bus
+	{
+		std::string name;
+		std::list<BusClient *> clients;
+		std::list<BusClient *> servers;
+		Arts::Synth_MULTI_ADD left, right;
+	};
+	std::list<Bus *> _busList;
+
+	BusManager();
+
+public:
+	Bus* findBus(const std::string& name);
+
+	void addClient(const std::string& busname, BusClient *client);
+	void removeClient(BusClient *client);
+	void addServer(const std::string& busname, BusClient *server);
+	void removeServer(BusClient *server);
+
+	std::vector<std::string> *busList();
+
+	static BusManager *the();
+};
+}
+
+#endif /* ARTS_BUS_H */
diff --git a/flow/bytestreamtoaudio_impl.cc b/flow/bytestreamtoaudio_impl.cc
new file mode 100644
index 0000000..73714cf
--- /dev/null
+++ b/flow/bytestreamtoaudio_impl.cc
@@ -0,0 +1,119 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+#include "resample.h"
+
+#include <cstring>
+
+using namespace std;
+using namespace Arts;
+
+namespace Arts {
+
+class PacketRefiller : public Refiller {
+protected:
+	queue< DataPacket<mcopbyte>* > inqueue;
+	int pos;
+
+public:
+	PacketRefiller() : pos(0)
+	{
+	}
+	void process(DataPacket<mcopbyte>* packet)
+	{
+		inqueue.push(packet);
+	}
+	unsigned long read(unsigned char *buffer, unsigned long bytes)
+	{
+		unsigned long done = 0;
+		while(!inqueue.empty())
+		{
+			long tocopy = bytes - done;
+			if(tocopy == 0) return bytes;			/* complete? */
+
+			DataPacket<mcopbyte> *packet = inqueue.front();
+			if(tocopy > (packet->size - pos))
+				tocopy = (packet->size - pos);
+
+			memcpy(&buffer[done],&packet->contents[pos],tocopy);
+			pos += tocopy;
+			done += tocopy;
+
+			if(pos == packet->size) {
+				packet->processed();
+				pos = 0;
+				inqueue.pop();
+			}
+		}
+		return done;
+	}
+};
+
+class ByteStreamToAudio_impl : public ByteStreamToAudio_skel,
+                               public StdSynthModule
+{
+	PacketRefiller refiller;
+	Resampler resampler;
+	long _samplingRate, _channels, _bits;
+public:
+	ByteStreamToAudio_impl() :resampler(&refiller),
+			_samplingRate(44100), _channels(2), _bits(16)
+	{
+		//
+	}
+
+	long samplingRate() { return _samplingRate; }
+	void samplingRate(long newRate) {
+		_samplingRate = newRate;
+		resampler.setStep((float)_samplingRate / samplingRateFloat);
+	}
+
+	long channels() { return _channels; }
+	void channels(long newChannels) {
+		_channels = newChannels;
+		resampler.setChannels(_channels);
+	}
+
+	long bits() { return _bits; }
+	void bits(long newBits) {
+		_bits = newBits;
+		resampler.setBits(_bits);
+	}
+
+	bool running() { return !resampler.underrun(); }
+
+	void process_indata(DataPacket<mcopbyte> *packet)
+	{
+		refiller.process(packet);
+	}
+
+	void calculateBlock(unsigned long samples)
+	{
+		resampler.run(left,right,samples);
+	}
+};
+
+REGISTER_IMPLEMENTATION(ByteStreamToAudio_impl);
+
+}
diff --git a/flow/cache.cc b/flow/cache.cc
new file mode 100644
index 0000000..0c7cfcc
--- /dev/null
+++ b/flow/cache.cc
@@ -0,0 +1,274 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "cache.h"
+#include "debug.h"
+#include "iomanager.h"
+#include "dispatcher.h"
+#include <iostream>
+#include <assert.h>
+
+using namespace std;
+using namespace Arts;
+
+bool CachedObject::isValid()
+{
+	return true;
+}
+
+void CachedObject::setKey(string key)
+{
+	_object_key = key;
+}
+
+string CachedObject::getKey()
+{
+	return _object_key;
+}
+
+void CachedObject::decRef()
+{
+	_ref_cnt--;
+	time(&_lastAccess);
+}
+
+void CachedObject::incRef()
+{
+	_ref_cnt++;
+}
+
+int CachedObject::refCnt()
+{
+	return _ref_cnt;
+}
+
+time_t CachedObject::lastAccess()
+{
+	return(_lastAccess);
+}
+
+CachedObject::CachedObject(Cache *cache)
+{
+	_ref_cnt = 1;
+	cache->add(this);
+}
+
+CachedObject::~CachedObject()
+{
+	assert(_ref_cnt == 0);
+}
+
+//------------------------- Cache implementation ---------------------------
+long Cache::memused = 0;
+
+CachedObject *Cache::get(string key)
+{
+	list<CachedObject *>::iterator i;
+
+	for(i=objects.begin();i != objects.end(); i++)
+	{
+		if((*i)->getKey() == key && (*i)->isValid())
+		{
+			(*i)->incRef();
+			return(*i);
+		}
+	}
+	return 0;
+}
+
+void Cache::add(CachedObject *object)
+{
+	objects.push_back(object);
+}
+
+long Cache::cleanUp(long cacheLimit)
+{
+	time_t lastAccess;
+
+	list<CachedObject *>::iterator i;
+	long memory = 0;
+
+	// delete all invalid unused entries (invalid entries that are still
+	// in use, e.g. cached wav files which have changed on disk but are
+	// still played can't be deleted!)
+	
+	for(i=objects.begin();i != objects.end(); i++)
+	{
+		CachedObject *co = (*i);
+
+		if(co->refCnt() == 0 && !co->isValid())
+		{
+			objects.remove(co);
+			delete co;
+			i = objects.begin();
+		}
+	}
+
+	for(i=objects.begin();i != objects.end(); i++)
+	{
+		memory += (*i)->memoryUsage();
+	}
+
+	bool freeok = true;
+	while(memory > cacheLimit && freeok)
+	{
+		CachedObject *freeme;
+
+		freeok = false;
+
+		// only start freeing objects which have not been accessed
+		// in the last 5 seconds
+
+		time(&lastAccess);
+		lastAccess -= 5;
+
+
+		for(i=objects.begin();!freeok && (i != objects.end()); i++)
+		{
+			CachedObject *co = (*i);
+
+			assert(co->refCnt() >= 0);
+			if(co->refCnt() == 0 && (co->lastAccess() < lastAccess))
+			{
+				lastAccess = co->lastAccess();
+				freeme = co;
+				freeok = true;
+			}
+			else
+			{
+				//artsdebug("%d => %ld\n",co->refCnt(),co->lastAccess());
+			}
+		}
+
+		if(freeok)
+		{
+			memory -= freeme->memoryUsage();
+			objects.remove(freeme);
+			delete(freeme);
+		}
+		else
+		{
+			//artsdebug("cache problem: memory overused, but nothing there to free\n");
+		}
+	}
+
+	memused = memory/1024;
+	return(memory);
+}
+
+Cache *Cache::_instance = 0;
+
+Cache::Cache()
+{
+	assert(!_instance);
+	_instance = this;
+}
+
+Cache::~Cache()
+{
+	list<CachedObject *>::iterator i;
+	for(i=objects.begin(); i != objects.end(); i++)
+		delete (*i);
+	objects.clear();
+
+	assert(_instance);
+	_instance = 0;
+}
+
+
+Cache *Cache::the()
+{
+	if(!_instance) _instance = new Cache();
+	return _instance;
+}
+
+void Cache::shutdown()
+{
+	if(_instance)
+	{
+		list<CachedObject *>::iterator i;
+		long rcnt = 0;
+		for(i=_instance->objects.begin(); i != _instance->objects.end(); i++)
+			rcnt += (*i)->refCnt();
+
+		if(rcnt == 0)
+		{
+			delete _instance;
+			_instance = 0;
+		}
+		else
+		{
+			arts_warning("cache shutdown while still active objects in cache");
+		}
+	}
+}
+
+namespace Arts {			// internal helpers
+
+// periodic cache clean
+class CacheClean : public TimeNotify {
+public:
+	CacheClean();
+	void notifyTime();
+	virtual ~CacheClean();
+};
+
+// cache startup & shutdown
+class CacheStartup :public StartupClass
+{
+public:
+	void startup();
+	void shutdown();
+private:
+	CacheClean *cacheClean;
+};
+
+}
+
+CacheClean::CacheClean()
+{
+	Dispatcher::the()->ioManager()->addTimer(5000, this);
+}
+
+void CacheClean::notifyTime()
+{
+	// TODO: make this configurable
+	Cache::the()->cleanUp(8192*1024);
+}
+
+CacheClean::~CacheClean()
+{
+	Dispatcher::the()->ioManager()->removeTimer(this);
+}
+
+void CacheStartup::startup()
+{
+	cacheClean = new CacheClean;	
+}
+
+void CacheStartup::shutdown()
+{
+	delete cacheClean;
+	Cache::shutdown();
+}
+
+static CacheStartup cacheStartup;
diff --git a/flow/cache.h b/flow/cache.h
new file mode 100644
index 0000000..3f093df
--- /dev/null
+++ b/flow/cache.h
@@ -0,0 +1,92 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef _SYNTH_CACHE_H
+#define _SYNTH_CACHE_H
+
+#include <time.h>
+#include <list>
+#include <string>
+#include "startupmanager.h"
+#include "arts_export.h"
+
+/*
+ * BC - Status (2002-03-08): Cache, CachedObject
+ *
+ * At the current point in time, there are NO GUARANTEES, so only use this
+ * in apps part of official KDE releases (such as kdemultimedia apps), which
+ * know what is happening here.
+ */
+
+namespace Arts {
+class Cache;
+
+class ARTS_EXPORT CachedObject
+{
+private:
+	std::string _object_key;
+	int _ref_cnt;
+	time_t _lastAccess;
+
+protected:
+	void setKey(std::string key);
+
+public:
+	std::string getKey();
+
+	time_t lastAccess();
+
+	void decRef();
+	void incRef();
+	int refCnt();
+
+	virtual bool isValid();
+	virtual int memoryUsage() = 0;
+
+	CachedObject(Cache *cache);
+	virtual ~CachedObject();
+};
+
+class ARTS_EXPORT Cache
+{
+protected:
+	std::list<CachedObject *> objects;
+	Cache();
+	~Cache();
+
+	static Cache *_instance;
+
+public:
+	static Cache *the();
+	static void shutdown();
+
+	static long memused;
+
+	CachedObject *get(std::string key);
+	void add(CachedObject *object);
+
+	// garbage collection; returns amount of memory used (after cleaning)
+	long cleanUp(long cacheLimit);
+};
+
+}
+#endif
diff --git a/flow/cachedwav.h b/flow/cachedwav.h
new file mode 100644
index 0000000..99df156
--- /dev/null
+++ b/flow/cachedwav.h
@@ -0,0 +1,81 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef CACHEDWAV_H
+#define CACHEDWAV_H
+
+#include "config.h"
+#include "arts_export.h"
+#ifdef HAVE_LIBAUDIOFILE
+#include "cache.h"
+#include <sys/stat.h>
+#include <unistd.h>
+
+/*
+ * BC - Status (2002-03-08): CachedWav.
+ *
+ * At the current point in time, there are NO GUARANTEES, so only use this
+ * in apps part of official KDE releases (such as kdemultimedia apps), which
+ * know what is happening here. Especially, in SOME kde versions this class
+ * might not even exist, as it gets conditionally compiled.
+ */
+
+namespace Arts {
+
+class ARTS_EXPORT CachedWav : public CachedObject
+{
+protected:
+	struct stat oldstat;
+	std::string filename;
+	bool initOk;
+
+	CachedWav(Cache *cache, std::string filename);
+	~CachedWav();
+
+	typedef unsigned char uchar;
+public:
+	double samplingRate;
+	long bufferSize;
+	int channelCount;
+	int sampleWidth;
+	unsigned char *buffer;
+
+	static CachedWav *load(Cache *cache, std::string filename);
+	/**
+	 * validity test for the cache - returns false if the object is having
+	 * reflecting the correct contents anymore (e.g. if the file on the
+	 * disk has changed), and there is no point in keeping it in the cache any
+	 * longer
+	 */
+	bool isValid();
+	/**
+	 * memory usage for the cache
+	 */
+	int memoryUsage();
+    
+	std::string mediaName() const { return filename; }
+};
+
+}
+
+#endif /* HAVE_LIBAUDIOFILE */
+#endif /* CACHEDWAV_H */
diff --git a/flow/convert.cc b/flow/convert.cc
new file mode 100644
index 0000000..d5ca2f8
--- /dev/null
+++ b/flow/convert.cc
@@ -0,0 +1,418 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "convert.h"
+#include <math.h>
+#include <string.h>
+#include <assert.h>
+#include <config.h>
+
+#ifdef HAVE_X86_FLOAT_INT
+static inline long QRound (float inval)
+{
+#if (__GNUC__ == 3 && __GNUC_MINOR__ == 0)
+  volatile
+#warning "workaround for gcc-3.0 bug c++/2733 enabled"
+#endif
+  int ret;
+  __asm__ ("fistpl %0" : "=m" (ret) : "t" (inval) : "st");
+  return ret;
+}
+#else
+static inline long QRound (float inval)
+{
+  return (long)inval;
+}
+#endif
+
+/*---------------------------- new code begin -------------------------- */
+
+#define compose_16le(ptr) \
+	((((*((ptr)+1)+128)&0xff) << 8)+*(ptr))
+
+#define compose_16be(ptr) \
+	((((*(ptr)+128)&0xff) << 8)+*((ptr)+1))
+
+#define conv_16_float(x) \
+	((float)((x)-32768)/32768.0)
+
+#define convert_16le_float(x) conv_16_float(compose_16le(&(x)))
+#define convert_16be_float(x) conv_16_float(compose_16be(&(x)))
+
+#define conv_8_float(x) \
+	((float)((x)-128)/128.0)
+
+#define convert_8_float(x) \
+	((float)((x)-128)/128.0)
+
+#define convert_float_float(x) x
+
+/*
+ * 16le, 16be, 8, float
+ */
+
+#define datatype_16le unsigned char
+#define datasize_16le 2
+
+#define datatype_16be unsigned char
+#define datasize_16be 2
+
+#define datatype_8 unsigned char
+#define datasize_8 1
+
+#define datatype_float float
+#define datasize_float 1
+
+#define mk_converter(from_format,to_format) \
+void Arts::convert_mono_ ## from_format ## _ ## to_format (unsigned long samples, \
+									datatype_ ## from_format *from, \
+                                    datatype_ ## to_format *to) \
+{ \
+	datatype_ ## to_format *end = to+samples * (datasize_ ## to_format); \
+	while(to<end) { \
+		*to = convert_ ## from_format ## _ ## to_format(*from); \
+		from += datasize_ ## from_format; \
+		to += datasize_ ## to_format; \
+	} \
+} \
+void Arts::interpolate_mono_ ## from_format ## _ ## to_format (unsigned long samples,\
+									double startpos, double speed, \
+									datatype_ ## from_format *from, \
+                                    datatype_ ## to_format *to) \
+{ \
+	double flpos = startpos; \
+	while(samples) { \
+		long position = ((long)(flpos)) * (datasize_ ## from_format); \
+		double error = flpos - floor(flpos); \
+		*to =	(convert_ ## from_format ## _ ## to_format(from[position])) * \
+				(1.0-error) + (convert_ ## from_format ## _ ## \
+				to_format(from[position + datasize_ ## from_format])) * error; \
+		to += datasize_ ## to_format; \
+		flpos += speed; \
+		samples--; \
+	} \
+} \
+void Arts::convert_stereo_i ## from_format ## _2 ## to_format (unsigned long samples,\
+									datatype_ ## from_format *from, \
+                                    datatype_ ## to_format *left, \
+									datatype_ ## to_format *right) \
+{ \
+	datatype_ ## to_format *end = left+samples * (datasize_ ## to_format); \
+	while(left<end) { \
+		*left = convert_ ## from_format ## _ ## to_format(*from); \
+		from += datasize_ ## from_format; \
+		left += datasize_ ## to_format; \
+		*right = convert_ ## from_format ## _ ## to_format(*from); \
+		from += datasize_ ## from_format; \
+		right += datasize_ ## to_format; \
+	} \
+} \
+void Arts::interpolate_stereo_i ## from_format ## _2 ## to_format (unsigned long samples,\
+									double startpos, double speed, \
+									datatype_ ## from_format *from, \
+                                    datatype_ ## to_format *left, \
+                                    datatype_ ## to_format *right) \
+{ \
+	double flpos = startpos; \
+	while(samples) { \
+		long position = ((long)(flpos)) * (datasize_ ## from_format) * 2; \
+		double error = flpos - floor(flpos); \
+		*left =	(convert_ ## from_format ## _ ## to_format(from[position])) * \
+				(1.0-error) + (convert_ ## from_format ## _ ## \
+				to_format(from[position + 2*datasize_ ## from_format]))*error; \
+		left += datasize_ ## to_format; \
+		position += datasize_ ## from_format; \
+		*right =(convert_ ## from_format ## _ ## to_format(from[position])) * \
+				(1.0-error) + (convert_ ## from_format ## _ ## \
+				to_format(from[position + 2*datasize_ ## from_format]))*error; \
+		right += datasize_ ## to_format; \
+		flpos += speed; \
+		samples--; \
+	} \
+}
+
+mk_converter(8,float)
+mk_converter(16le,float)
+mk_converter(16be,float)
+mk_converter(float,float)
+
+/*----------------------------- new code end --------------------------- */
+
+/*
+void old_convert_mono_8_float(unsigned long samples, unsigned char *from, float *to)
+{
+	float *end = to+samples;
+
+	while(to<end) *to++ = conv_8_float(*from++);
+}
+
+void old_convert_mono_16le_float(unsigned long samples, unsigned char *from, float *to)
+{
+	float *end = to+samples;
+
+	while(to<end)
+	{
+		*to++ = conv_16le_float(compose_16le(from));
+		from += 2;
+	}
+}
+
+
+void old_convert_stereo_i8_2float(unsigned long samples, unsigned char *from, float *left, float *right)
+{
+	float *end = left+samples;
+	while(left < end)
+	{
+		*left++ = conv_8_float(*from++);
+		*right++ = conv_8_float(*from++);
+	}
+}
+
+void old_convert_stereo_i16le_2float(unsigned long samples, unsigned char *from, float *left, float *right)
+{
+	float *end = left+samples;
+	while(left < end)
+	{
+		*left++ = conv_16le_float(compose_16le(from));
+		*right++ = conv_16le_float(compose_16le(from+2));
+		from += 4;
+	}
+}
+*/
+
+void Arts::convert_stereo_2float_i16le(unsigned long samples, float *left, float *right, unsigned char *to)
+{
+	float *end = left+samples;
+	long syn;
+
+	while(left < end)
+	{
+		syn = QRound((*left++)*32767);
+
+		if(syn < -32768) syn = -32768;				/* clipping */
+		if(syn > 32767) syn = 32767;
+
+		*to++ = syn & 0xff;
+		*to++ = (syn >> 8) & 0xff;
+
+		syn = QRound((*right++)*32767);
+
+		if(syn < -32768) syn = -32768;				/* clipping */
+		if(syn > 32767) syn = 32767;
+
+		*to++ = syn & 0xff;
+		*to++ = (syn >> 8) & 0xff;
+	}	
+}
+
+void Arts::convert_mono_float_16le(unsigned long samples, float *from, unsigned char *to)
+{
+	float *end = from+samples;
+
+	while(from < end)
+	{
+		long syn = QRound((*from++)*32767);
+
+		if(syn < -32768) syn = -32768;				/* clipping */
+		if(syn > 32767) syn = 32767;
+
+		*to++ = syn & 0xff;
+		*to++ = (syn >> 8) & 0xff;
+	}	
+}
+
+void Arts::convert_stereo_2float_i16be(unsigned long samples, float *left, float *right, unsigned char *to)
+{
+	float *end = left+samples;
+	long syn;
+
+	while(left < end)
+	{
+		syn = QRound((*left++)*32767);
+
+		if(syn < -32768) syn = -32768;				/* clipping */
+		if(syn > 32767) syn = 32767;
+
+		*to++ = (syn >> 8) & 0xff;
+		*to++ = syn & 0xff;
+
+		syn = QRound((*right++)*32767);
+
+		if(syn < -32768) syn = -32768;				/* clipping */
+		if(syn > 32767) syn = 32767;
+
+		*to++ = (syn >> 8) & 0xff;
+		*to++ = syn & 0xff;
+	}	
+}
+
+void Arts::convert_mono_float_16be(unsigned long samples, float *from, unsigned char *to)
+{
+	float *end = from+samples;
+
+	while(from < end)
+	{
+		long syn = QRound((*from++)*32767);
+
+		if(syn < -32768) syn = -32768;				/* clipping */
+		if(syn > 32767) syn = 32767;
+
+		*to++ = (syn >> 8) & 0xff;
+		*to++ = syn & 0xff;
+	}	
+}
+
+void Arts::convert_stereo_2float_i8(unsigned long samples, float *left, float *right, unsigned char *to)
+{
+	float *end = left+samples;
+	long syn;
+
+	while(left < end)
+	{
+		syn = (int)((*left++)*127+128);
+
+		if(syn < 0) syn = 0;					/* clipping */
+		if(syn > 255) syn = 255;
+
+		*to++ = syn;
+
+		syn = (int)((*right++)*127+128);
+
+		if(syn < 0) syn = 0;					/* clipping */
+		if(syn > 255) syn = 255;
+
+		*to++ = syn;
+	}	
+}
+
+void Arts::convert_mono_float_8(unsigned long samples, float *from, unsigned char *to)
+{
+	float *end = from+samples;
+
+	while(from < end)
+	{
+		long syn = (int)((*from++)*127+128);
+
+		if(syn < 0) syn = 0;					/* clipping */
+		if(syn > 255) syn = 255;
+
+		*to++ = syn;
+	}	
+}
+
+unsigned long Arts::uni_convert_stereo_2float(
+		unsigned long samples,		// number of required samples
+		unsigned char *from,		// buffer containing the samples
+		unsigned long fromLen,		// length of the buffer
+	    unsigned int fromChannels,  // channels stored in the buffer
+		unsigned int fromBits,		// number of bits per sample
+	    float *left, float *right,	// output buffers for left and right channel
+		double speed,				// speed (2.0 means twice as fast)
+		double startposition		// startposition
+	)
+{
+	unsigned long doSamples = 0, sampleSize = fromBits/8;
+
+	if(fromBits == uni_convert_float_ne)
+		sampleSize = sizeof(float);
+
+	// how many samples does the from-buffer contain?
+	double allSamples = fromLen / (fromChannels * sampleSize);
+
+	// how many samples are remaining?
+	//    subtract one due to interpolation and another against rounding errors
+	double fHaveSamples = allSamples - startposition - 2.0;
+	fHaveSamples /= speed;
+
+	// convert do "how many samples to do"?
+	if(fHaveSamples > 0)
+	{
+		doSamples = (int)fHaveSamples;
+		if(doSamples > samples) doSamples = samples;
+	}
+
+	// do conversion
+	if(doSamples)
+	{
+		if(fromChannels == 1)
+		{
+			if(fromBits == uni_convert_float_ne) {
+				interpolate_mono_float_float(doSamples,
+							startposition,speed,(float *)from,left);
+			}
+			else if(fromBits == uni_convert_s16_be) {
+				interpolate_mono_16be_float(doSamples,
+							startposition,speed,from,left);
+			}
+			else if(fromBits == uni_convert_s16_le) {
+				interpolate_mono_16le_float(doSamples,
+							startposition,speed,from,left);
+			}
+			else {
+				interpolate_mono_8_float(doSamples,
+							startposition,speed,from,left);
+			}
+			memcpy(right,left,sizeof(float)*doSamples);
+		}
+		else if(fromChannels == 2)
+		{
+			if(fromBits == uni_convert_float_ne) {
+				interpolate_stereo_ifloat_2float(doSamples,
+							startposition,speed,(float *)from,left,right);
+			}
+			else if(fromBits == uni_convert_s16_be) {
+				interpolate_stereo_i16be_2float(doSamples,
+							startposition,speed,from,left,right);
+			}
+			else if(fromBits == uni_convert_s16_le) {
+				interpolate_stereo_i16le_2float(doSamples,
+							startposition,speed,from,left,right);
+			}
+			else {
+				interpolate_stereo_i8_2float(doSamples,
+							startposition,speed,from,left,right);
+			}
+		} else {
+			assert(false);
+		}
+	}
+	return doSamples;
+}
+
+// undefine all that stuff (due to --enable-final)
+#undef compose_16le
+#undef compose_16be
+#undef conv_16_float
+#undef convert_16le_float
+#undef convert_16be_float
+#undef conv_8_float
+#undef convert_8_float
+#undef convert_float_float
+#undef datatype_16le
+#undef datasize_16le
+#undef datatype_16be
+#undef datasize_16be
+#undef datatype_8
+#undef datasize_8
+#undef datatype_float
+#undef datasize_float
+#undef mk_converter
diff --git a/flow/convert.h b/flow/convert.h
new file mode 100644
index 0000000..35551a1
--- /dev/null
+++ b/flow/convert.h
@@ -0,0 +1,164 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef _arts_convert_h
+#define _arts_convert_h
+
+#include "arts_export.h"
+
+/*
+ * BC - Status (2002-03-08): conversion functions
+ *
+ * None of them will be removed or changed, so it is safe to use them in
+ * your apps. It is *recommended* (though not necessary) to use the new
+ * resampling code (Resampler) where possible.
+ */
+
+namespace Arts {
+
+/*
+ * Simple conversion routines. The function names are chosen like
+ *
+ *   convert_mono_FROM_TO for mono conversions
+ *   convert_stereo_FROM_TO for stereo conversions
+ *
+ * while FROM/TO are
+ *
+ *      8 for  8bit signed data
+ *   16le for 16bit signed little endian
+ *  float for float data between -1 and 1
+ *
+ * and may be prefixed by 2 to indicate that stereo is done with two seperate
+ * buffers or i to indicate interleaved stereo (one buffer which contains
+ * one sample left, one sample right, one sample left etc.)
+ *
+ * The parameter speed (for interpolations) is *not* the samplingrate, but
+ * a relative value. A speed of 2.0 means "play twice as fast".
+ */
+
+// upconversions from integer to float
+void ARTS_EXPORT convert_mono_8_float(unsigned long samples,
+			unsigned char *from, float *to);
+
+void ARTS_EXPORT interpolate_mono_8_float(unsigned long samples,
+		    double startpos, double speed,
+			unsigned char *from, float *to);
+
+void ARTS_EXPORT convert_mono_16le_float(unsigned long samples,
+			unsigned char *from, float *to);
+
+void ARTS_EXPORT interpolate_mono_16le_float(unsigned long samples,
+		    double startpos, double speed,
+			unsigned char *from, float *to);
+
+void ARTS_EXPORT convert_mono_16be_float(unsigned long samples,
+			unsigned char *from, float *to);
+
+void ARTS_EXPORT interpolate_mono_16be_float(unsigned long samples,
+		    double startpos, double speed,
+			unsigned char *from, float *to);
+
+void ARTS_EXPORT convert_stereo_i8_2float(unsigned long samples,
+			unsigned char *from, float *left, float *right);
+
+void ARTS_EXPORT interpolate_stereo_i8_2float(unsigned long samples,
+		    double startpos, double speed,
+			unsigned char *from, float *left, float *right);
+
+void ARTS_EXPORT convert_stereo_i16le_2float(unsigned long samples,
+			unsigned char *from, float *left, float *right);
+
+void ARTS_EXPORT interpolate_stereo_i16le_2float(unsigned long samples,
+		    double startpos, double speed,
+			unsigned char *from, float *left, float *right);
+
+void ARTS_EXPORT convert_stereo_i16be_2float(unsigned long samples,
+			unsigned char *from, float *left, float *right);
+
+void ARTS_EXPORT interpolate_stereo_i16be_2float(unsigned long samples,
+		    double startpos, double speed,
+			unsigned char *from, float *left, float *right);
+
+void ARTS_EXPORT convert_mono_float_float(unsigned long samples,
+			float *from, float *to);
+
+void ARTS_EXPORT interpolate_mono_float_float(unsigned long samples,
+		    double startpos, double speed,
+			float *from, float *to);
+
+void ARTS_EXPORT convert_stereo_ifloat_2float(unsigned long samples,
+			float *from, float *left, float *right);
+
+void ARTS_EXPORT interpolate_stereo_ifloat_2float(unsigned long samples,
+		    double startpos, double speed,
+			float *from, float *left, float *right);
+
+// downconversions from float to integer
+void ARTS_EXPORT convert_mono_float_16le(unsigned long samples,
+			float *from, unsigned char *to);
+
+void ARTS_EXPORT convert_stereo_2float_i16le(unsigned long samples,
+			float *left, float *right, unsigned char *to);
+
+void ARTS_EXPORT convert_mono_float_16be(unsigned long samples,
+			float *from, unsigned char *to);
+
+void ARTS_EXPORT convert_stereo_2float_i16be(unsigned long samples,
+			float *left, float *right, unsigned char *to);
+
+void ARTS_EXPORT convert_mono_float_8(unsigned long samples,
+			float *from, unsigned char *to);
+
+void ARTS_EXPORT convert_stereo_2float_i8(unsigned long samples,
+			float *left, float *right, unsigned char *to);
+
+
+/*
+ * This practical routine picks the right conversion routine for given
+ * parameters and makes boundary checks
+ */
+
+// returnvalue: number of samples generated
+
+/* formats for unified conversion */
+enum {
+  uni_convert_u8         = 8,		// unsigned 8 bit
+  uni_convert_s16_le     = 16,		// signed 16 bit, little endian
+  uni_convert_s16_be     = 17,		// signed 16 bit, big endian
+  uni_convert_float_ne   = 0x100	// float, in native size/byteorder
+};
+
+unsigned long ARTS_EXPORT uni_convert_stereo_2float(
+		unsigned long samples,		// number of required samples
+		unsigned char *from,		// buffer containing the samples
+		unsigned long fromLen,		// length of the buffer
+	    unsigned int fromChannels,  // channels stored in the buffer
+		unsigned int fromBits,		// number of bits per sample
+									//  (also: uni_convert_ formats given above)
+	    float *left, float *right,	// output buffers for left and right channel
+		double speed,				// speed (2.0 means twice as fast)
+		double startposition		// startposition
+	);
+
+}
+
+#endif
diff --git a/flow/cpuinfo.cc b/flow/cpuinfo.cc
new file mode 100644
index 0000000..8b03295
--- /dev/null
+++ b/flow/cpuinfo.cc
@@ -0,0 +1,232 @@
+    /*
+
+    Copyright (C) 2001 Malte Starostik <malte@kde.org>
+	              2001 Darian Lanx <bio@gmx.net>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include <config.h>
+#include "startupmanager.h"
+#include "cpuinfo.h"
+
+#include <setjmp.h>
+#include <signal.h>
+
+using namespace Arts;
+
+int CpuInfo::s_flags = 0;
+
+namespace Arts
+{
+	class CpuInfoStartup : public StartupClass
+	{
+	public:
+		virtual void startup();
+	
+	private:
+		static jmp_buf s_sseCheckEnv;
+		static void sseCheckHandler(int);
+	};
+}
+
+jmp_buf CpuInfoStartup::s_sseCheckEnv;
+
+void CpuInfoStartup::sseCheckHandler(int)
+{
+	longjmp(s_sseCheckEnv, 1);
+}
+
+void CpuInfoStartup::startup()
+{
+#ifdef HAVE_X86_SSE
+/*
+ * Taken with thanks from mmx.h:
+ * 
+ * MultiMedia eXtensions GCC interface library for IA32.
+ * 
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
+ * LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR ANY PARTICULAR PURPOSE.
+ */
+
+/* Returns 1 if MMX instructions are supported,
+ *         3 if Cyrix MMX and Extended MMX instructions are supported
+ *         5 if AMD MMX and 3DNow! instructions are supported
+ *         9 if MMX and Intel ISSE instructions are supported
+ *         0 if hardware does not support any of these
+*/
+	__asm__ __volatile__ (
+		"pushl %%ebx                           \n\t"
+		"pushl %%ecx                           \n\t"
+		"pushl %%edx                           \n\t"
+
+		// See if CPUID instruction is supported ...
+		// ... Get copies of EFLAGS into eax and ecx
+		"pushf                                 \n\t"
+		"popl  %%eax                           \n\t"
+		"movl  %%eax, %%ecx                    \n\t"
+
+		// ... Toggle the ID bit in one copy and store
+		//     to the EFLAGS reg
+		"xorl  $0x00200000, %%eax              \n\t"
+		"push  %%eax                           \n\t"
+		"popf                                  \n\t"
+
+		// ... Get the (hopefully modified) EFLAGS
+		"pushf                                 \n\t"
+		"popl  %%eax                           \n\t"
+
+		// ... Compare and test result
+		"xorl  %%eax, %%ecx                    \n\t"
+		"testl $0x00200000, %%ecx              \n\t"
+		"jz    NotSupported                    \n\t"
+
+		// Get standard CPUID information, and
+		// go to a specific vendor section
+		"movl  $0, %%eax                       \n\t"
+		"cpuid                                 \n\t"
+
+		// Check for Intel
+		"cmpl  $0x756e6547, %%ebx              \n\t" // Genu
+		"jne   TryAMD                          \n\t"
+		"cmpl  $0x49656e69, %%edx              \n\t" // ineI
+		"jne   TryAMD                          \n\t"
+		"cmpl  $0x6c65746e, %%ecx              \n\t" // ntel
+		"jne   TryAMD                          \n\t"
+		"jmp   Intel                           \n\t"
+
+		// Check for AMD
+		"TryAMD:                               \n\t"
+		"cmpl  $0x68747541, %%ebx              \n\t" // Auth
+		"jne   TryCyrix                        \n\t"
+		"cmpl  $0x69746e65, %%edx              \n\t" // enti
+		"jne   TryCyrix                        \n\t"
+		"cmpl  $0x444d4163, %%ecx              \n\t" // cAMD
+		"jne   TryCyrix                        \n\t"
+		"jmp   AMD                             \n\t"
+
+		// Check for Cyrix
+		"TryCyrix:                             \n\t"
+		"cmpl  $0x69727943, %%ebx              \n\t" // Cyri
+		"jne   NotSupported                    \n\t"
+		"cmpl  $0x736e4978, %%edx              \n\t" // xIns
+		"jne   NotSupported                    \n\t"
+		"cmpl  $0x64616574, %%ecx              \n\t" // tead
+		"jne   NotSupported                    \n\t"
+		// Drop through to Cyrix...
+
+		// Cyrix Section
+		// See if extended CPUID is supported
+		"movl  $0x80000000, %%eax              \n\t"
+		"cpuid                                 \n\t"
+		"cmpl  $0x80000000, %%eax              \n\t"
+		"jl MMXtest                            \n\t" // try std CPUID
+
+		// Extended CPUID supported, so get extended features
+		"movl  $0x80000001, %%eax              \n\t"
+		"cpuid                                 \n\t"
+		"testl $0x00800000, %%eax              \n\t" // test for MMX
+		"jz    NotSupported                    \n\t" // no MMX
+		"movl  $1, %0                          \n\t" // has MMX
+		"testl $0x01000000, %%eax              \n\t" // test for EMMX
+		"jz    Return                          \n\t" // no EMMX
+		"addl  $2, %0                          \n\t" // has EMMX
+		"jmp   Return                          \n\t"
+
+		// AMD Section
+		"AMD:                                  \n\t"
+
+		// See if extended CPUID is supported
+		"movl  $0x80000000, %%eax              \n\t"
+		"cpuid                                 \n\t"
+		"cmpl  $0x80000000, %%eax              \n\t"
+		"jl     MMXtest                        \n\t" // try std CPUID
+
+		// Extended CPUID supported, so get extended features
+		"movl  $0x80000001, %%eax              \n\t"
+		"cpuid                                 \n\t"
+		"testl $0x00800000, %%edx              \n\t" // test for MMX
+		"jz    NotSupported                    \n\t" // no MMX
+		"movl  $1, %0                          \n\t" // has MMX
+		"testl $0x80000000, %%edx              \n\t" // test for 3DNow!
+		"jz    Return                          \n\t"
+		"addl  $4, %0                          \n\t" // has 3DNow!
+		// Athlon(tm) XP has both 3DNow! and SSE
+		"pushl %%eax                           \n\t"
+		"movl  $1, %%eax                       \n\t"
+		"cpuid                                 \n\t"
+		"popl  %%eax                           \n\t"
+		"testl $0x02000000, %%edx              \n\t" // test for SSE
+		"jz    Return                          \n\t" // no SSE
+		"addl  $8, %0                          \n\t" // has SSE
+		"jmp   Return                          \n\t"
+
+		// Intel Section
+		"Intel:                                \n\t"
+
+		// Check for MMX
+		"MMXtest:                              \n\t"
+		"movl  $1, %%eax                       \n\t"
+		"cpuid                                 \n\t"
+		"testl $0x00800000, %%edx              \n\t" // test for MMX
+		"jz    NotSupported                    \n\t" // no MMX
+		"movl  $1, %0                          \n\t" // has MMX
+		"testl $0x02000000, %%edx              \n\t" // test for SSE
+		"jz    Return                          \n\t" // no SSE
+		"addl  $8, %0                          \n\t" // has SSE
+		"jmp   Return                          \n\t"
+
+		// Nothing supported
+		"NotSupported:                         \n\t"
+		"movl  $0, %0                          \n\t"
+
+		"Return:                               \n\t"
+		"popl  %%edx                           \n\t"
+		"popl  %%ecx                           \n\t"
+		"popl  %%ebx                           \n\t"
+		: "=a" (CpuInfo::s_flags)
+		: /* no input */
+		: "memory"
+	);
+	// SSE must be supported by the OS, if it's not, any SSE insn will
+	// trigger an invalid opcode exception, to check for this, a SIGILL
+	// handler is installed and a SSE insn run. If the handler is called,
+	// the SSE bit is cleared in CpuInfo::s_flags
+	if (CpuInfo::s_flags & CpuInfo::CpuSSE)
+	{
+		void (*oldHandler)(int) = signal(SIGILL, sseCheckHandler);
+		if (setjmp(s_sseCheckEnv))
+		{
+			CpuInfo::s_flags &= ~CpuInfo::CpuSSE;
+		}
+		else
+		{
+			__asm__ __volatile__ (
+				"subl $0x10, %esp     \n"
+				"movups %xmm0, (%esp) \n"
+				"emms                 \n"
+				"addl $0x10, %esp     \n"
+			);
+		}
+		signal(SIGILL, oldHandler);
+	}
+#endif /* HAVE_X86_SSE */
+}
+
+static CpuInfoStartup cpuInfoStartup;
diff --git a/flow/cpuinfo.h b/flow/cpuinfo.h
new file mode 100644
index 0000000..927f682
--- /dev/null
+++ b/flow/cpuinfo.h
@@ -0,0 +1,72 @@
+    /*
+
+    Copyright (C) 2001 Malte Starostik <malte@kde.org>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef _arts_cpuinfo_h
+#define _arts_cpuinfo_h
+
+#include "arts_export.h"
+/*
+ * BC - Status (2002-03-08): CpuInfo
+ *
+ * This class will be kept binary compatible - it just exports the static
+ * CpuInfo::flags() function as only functionality.
+ */
+
+namespace Arts {
+
+	/**
+	 * Provides information about the availability of the various
+	 * "Multimedia extensions" the CPU supports. If you implement
+	 * a routine in assembler, use @ref flags() to know which
+	 * SIMD instructions the user's CPU knows about.
+	 *
+	 * @short Information about the CPU's SIMD implementation
+	 */
+	class ARTS_EXPORT CpuInfo
+	{
+	public:
+		/**
+		 * Values for the detected features of the CPU:
+		 * @li CpuMMX - CPU supports MMX
+		 * @li CpuEMMX - CPU supports Cyrix Extended MMX
+		 * @li Cpu3DNow - CPU supports AMD 3DNow!
+		 * @li CpuSSE - CPU supports Intel SSE
+		 */
+		enum Flags
+		{
+			CpuMMX   = 0x001, // Pentium MMX
+			CpuEMMX  = 0x002, // Cyrix Extended MMX
+			Cpu3DNow = 0x004, // AMD 3DNow!
+			CpuSSE   = 0x008  // Pentium III SSE
+		};
+		/**
+		 * @return the @ref Flags values that correspond to the
+		 * CPU's features. Multiple values are bitwised or'ed
+		 */
+		static int flags() { return s_flags; }
+	
+	private:
+		friend class CpuInfoStartup;
+		static int s_flags;
+	};
+}
+
+#endif // _arts_cpuinfo_h
diff --git a/flow/datahandle_impl.cc b/flow/datahandle_impl.cc
new file mode 100644
index 0000000..e576e75
--- /dev/null
+++ b/flow/datahandle_impl.cc
@@ -0,0 +1,499 @@
+    /*
+
+    Copyright (C) 2002 Hans Meine
+                       hans_meine@gmx.net
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include <gsl/gsldatahandle.h>
+#include <gsl/gslloader.h>
+#include <gsl/gslwaveosc.h>
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+#include "debug.h"
+#include <algorithm>
+#include <cstring>
+#include <gslpp/datahandle.h>
+
+using namespace std;
+
+namespace Arts {
+
+static GSL::DataHandle getDHandle(DataHandle handle);
+
+class DataHandle_impl : virtual public DataHandle_skel
+{
+protected:
+	GSL::DataHandle dhandle_;
+	long errno_;
+	friend GSL::DataHandle getDHandle(DataHandle handle);
+
+public:
+	DataHandle_impl(GSL::DataHandle dhandle = GSL::DataHandle::null())
+		: dhandle_(dhandle)
+	{
+		errno_ = dhandle_.isNull() ? 0 : dhandle_.open();
+	}
+
+	~DataHandle_impl()
+	{
+		if(dhandle_.isOpen())
+			dhandle_.close();
+	}
+
+	long valueCount()
+	{
+		return dhandle_.valueCount();
+	}
+
+	long bitDepth()
+	{
+		return dhandle_.bitDepth();
+	}
+
+	long channelCount()
+	{
+		return dhandle_.channelCount();
+	}
+
+	long errorNo()
+	{
+		return errno_;
+	}
+
+	GSL::DataHandle createCropped(long headCutValueCount,
+								  long tailCutValueCount)
+	{
+		return dhandle_.createCropped(headCutValueCount, tailCutValueCount);
+	}
+
+	GSL::DataHandle createCut(long cutOffset,
+							  long cutValueCount)
+	{
+		return dhandle_.createCut(cutOffset, cutValueCount);
+	}
+
+	GSL::DataHandle createReversed()
+	{
+		return dhandle_.createReversed();
+	}
+};
+
+class ReversedDataHandle_impl : virtual public DataHandle_impl,
+								virtual public ReversedDataHandle_skel
+{
+	void init(DataHandle sourceHandle)
+	{
+		DataHandle_impl *impl = dynamic_cast<DataHandle_impl *>(sourceHandle._base());
+		dhandle_ = impl->createReversed();
+	}
+};
+
+class CroppedDataHandle_impl : virtual public DataHandle_impl,
+							   virtual public CroppedDataHandle_skel
+{
+	void init(DataHandle sourceHandle,
+			  long headCutValueCount,
+			  long tailCutValueCount)
+	{
+		DataHandle_impl *impl = dynamic_cast<DataHandle_impl *>(sourceHandle._base());
+		dhandle_ = impl->createCropped(headCutValueCount, tailCutValueCount);
+	}
+};
+
+class CutDataHandle_impl : virtual public DataHandle_impl,
+						   virtual public CutDataHandle_skel
+{
+	void init(DataHandle sourceHandle,
+			  long cutOffset,
+			  long cutValueCount)
+	{
+		DataHandle_impl *impl = dynamic_cast<DataHandle_impl *>(sourceHandle._base());
+		dhandle_ = impl->createCut(cutOffset, cutValueCount);
+	}
+};
+
+static GSL::DataHandle getDHandle(DataHandle handle)
+{
+	DataHandle_impl *impl = dynamic_cast<DataHandle_impl *>(handle._base());
+	if(impl)
+		return impl->dhandle_;
+	return GSL::DataHandle::null();
+}
+
+GslWaveChunk* const_wchunk_from_freq(gpointer wchunk_data, gfloat)
+{
+	return (GslWaveChunk*)wchunk_data;
+}
+
+// FIXME: Think about whether this is needed as a parameter like mixerFrequency
+#define OSCILLATOR_FREQUENCY 440.0f
+
+class DataHandlePlay_impl : virtual public DataHandlePlay_skel,
+							virtual public StdSynthModule
+{
+protected:
+	DataHandle dhandle_;
+
+	GSL::DataHandle gslDHandle_;
+	int errno_;
+	GslWaveChunk *wchunk_;
+	GslErrorType wchunkError_;
+	GslWaveOscData *wosc_;
+
+	float mixerFrequency_;
+	unsigned short channelIndex_;
+	float speed_;
+	unsigned long pos_;
+	bool finished_;
+	bool paused_;
+
+public:
+	DataHandlePlay_impl()
+		: dhandle_(DataHandle::null()),
+		  gslDHandle_(GSL::DataHandle::null()),
+		  wchunk_(NULL),
+		  wosc_(NULL),
+		  mixerFrequency_(0), // FIXME: doc says soundserver's freq
+		  channelIndex_(0),
+		  speed_(1.0f),
+		  pos_(0),
+		  finished_(false),
+		  paused_(false)
+	{}
+
+	~DataHandlePlay_impl()
+	{
+		handle(DataHandle::null());
+	}
+
+	DataHandle handle()
+	{
+		return dhandle_;
+	}
+
+	void handle(DataHandle handle)
+	{
+		deleteWaveChunk();
+
+		if(!gslDHandle_.isNull() && !errno_)
+			gslDHandle_.close();
+
+		dhandle_ = handle;
+
+		if(handle.isNull())
+			gslDHandle_ = GSL::DataHandle::null();
+		else
+		{
+			gslDHandle_ = getDHandle(dhandle_);
+
+			if(gslDHandle_.isNull())
+			{
+				arts_debug("ERROR: could not get internal GSL::DataHandle!");
+				finished(true); // FIXME: can this happen?
+			}
+			else
+			{
+				errno_ = gslDHandle_.open();
+				if(errno_)
+					arts_debug("DataHandlePlay got error from GSL::DataHandle.open(): '%s'",
+							   strerror(errno_));
+			}
+		}
+	}
+
+	void streamInit()
+	{
+		if(!gslDHandle_.isNull() && !wosc_)
+		{
+			if(!wchunk_)
+				createWaveChunk();
+			configureWaveOsc();
+		}
+	}
+
+	float mixerFrequency() { return wosc_ ? wosc_->mix_freq : 0; }
+	void mixerFrequency(float f)
+	{
+		if(wchunk_)
+			arts_warning("DataHandlePlay: cannot change mixerFrequency after start of sound processing!");
+
+		if(mixerFrequency() != f)
+		{
+			mixerFrequency_ = f;
+			mixerFrequency_changed(f);
+		}
+	}
+
+	long channelIndex() { return channelIndex_; }
+	void channelIndex(long ci)
+	{
+		if(channelIndex_ != ci)
+		{
+			channelIndex_ = ci;
+			if(wosc_)
+			{
+				GslWaveOscConfig config = wosc_->config;
+				config.channel = ci;
+				gsl_wave_osc_config(wosc_, &config);
+			}
+			channelIndex_changed(ci);
+		}
+	}
+
+	float speed() { return speed_; }
+	void speed(float s)
+	{
+		if(speed_ != s)
+		{
+			speed_ = s;
+			if(wosc_)
+			{
+				GslWaveOscConfig config = wosc_->config;
+				config.cfreq = OSCILLATOR_FREQUENCY * speed();
+				gsl_wave_osc_config(wosc_, &config);
+			}
+			speed_changed(s);
+		}
+	}
+
+	long pos() { return wosc_ ? wosc_->block.offset : 0; }
+	void pos(long p)
+	{
+		if(pos() != p)
+		{
+			GslWaveOscConfig config = wosc_->config;
+			config.start_offset = p;
+			gsl_wave_osc_config(wosc_, &config);
+			pos_changed(p);
+		}
+	}
+
+	bool finished() { return finished_; }
+	void finished(bool f)
+	{
+		if(finished_ != f)
+		{
+			finished_ = f;
+			finished_changed(f);
+		}
+	}
+
+	bool paused() { return paused_; }
+	void paused(bool p)
+	{
+		paused_ = p;
+	}
+
+	void deleteWaveChunk()
+	{
+		deleteWaveOsc();
+
+		if(wchunk_)
+		{
+			arts_debug("DataHandlePlay_impl: close()ing gsl_wave_chunk");
+			gsl_wave_chunk_close(wchunk_);
+			gsl_wave_chunk_unref(wchunk_);
+			wchunk_ = NULL;
+		}
+	}
+
+	void createWaveChunk()
+	{
+		deleteWaveChunk();
+
+		if(!gslDHandle_.isNull() && gslDHandle_.isOpen())
+		{
+			GslDataCache *dcache = gslDHandle_.createGslDataCache();
+			if(!dcache)
+			{
+				arts_debug("FATAL: creating data cache failed!");
+				finished(true); // FIXME: can this happen?
+			}
+			else
+			{
+				wchunk_ =
+					gsl_wave_chunk_new(dcache,
+									   OSCILLATOR_FREQUENCY,
+									   mixerFrequency_,
+									   GSL_WAVE_LOOP_NONE,
+									   0, 0, 0);
+				arts_debug("DataHandlePlay_impl: open()ing gsl_wave_chunk");
+				wchunkError_ = gsl_wave_chunk_open(wchunk_);
+				gsl_data_cache_unref(dcache);
+			}
+		}
+	}
+
+	void deleteWaveOsc()
+	{
+		if(wosc_)
+		{
+			gsl_wave_osc_shutdown(wosc_);
+			delete wosc_;
+			wosc_ = NULL;
+		}
+	}
+
+	void configureWaveOsc()
+	{
+		if(wchunk_)
+		{
+			GslWaveOscConfig config;
+			memset(&config, 0, sizeof (GslWaveOscConfig));
+			config.start_offset = 0;
+			config.play_dir = 1;
+			config.wchunk_data = (gpointer)wchunk_;
+			config.wchunk_from_freq = &const_wchunk_from_freq;
+			config.channel = channelIndex();
+			config.cfreq = OSCILLATOR_FREQUENCY * speed();
+
+			if(!wosc_)
+			{
+				wosc_ = new GslWaveOscData();
+				gsl_wave_osc_init(wosc_);
+			}
+
+			gsl_wave_osc_config(wosc_, &config);
+		}
+	}
+
+	void calculateBlock(unsigned long samples)
+	{
+		if(!paused_ && wchunk_)
+		{
+			if (!gsl_wave_osc_process(wosc_, samples, 0, 0, 0, outvalue))
+				arts_debug("gsl_wave_osc_process failed.");
+			finished(wosc_->done);
+		}
+		else
+			for(unsigned long i = 0; i < samples; i++)
+				outvalue[i] = 0.f;
+		/*
+		unsigned long haveSamples = 0;
+
+		while(haveSamples != samples)
+		{
+			long n = min(gslDHandle_.valueCount() - pos_, samples - haveSamples);
+			long got = gslDHandle_.isNull() ?
+					   0 : gslDHandle_.read(pos_, n, &outvalue[haveSamples]);
+			if(got <= 0)
+			{
+				for(unsigned long i = haveSamples; i < samples; i++)
+					outvalue[i] = 0.f;
+				break;
+			}
+			pos_ += got;
+			haveSamples += got;
+		}
+		finished(pos_ >= gslDHandle_.valueCount());
+		*/
+	}
+
+	DataHandlePlay clone()
+	{
+		arts_debug("DataHandlePlay_impl: clone()ing myself");
+		DataHandlePlay_impl *result = new DataHandlePlay_impl();
+
+		result->dhandle_ = dhandle_;
+		result->gslDHandle_ = gslDHandle_;
+		result->errno_ = errno_;
+		
+		createWaveChunk();
+		if(wchunk_)
+		{
+			result->wchunk_ = wchunk_;
+			gsl_wave_chunk_ref(wchunk_);
+			result->wchunkError_ = gsl_wave_chunk_open(wchunk_);
+		}
+		else
+			result->wchunkError_ = wchunkError_;
+
+		result->mixerFrequency_ = mixerFrequency_;
+		result->channelIndex_ = channelIndex_;
+		result->speed_ = speed_;
+		result->pos_ = pos_;
+		result->finished_ = finished_;
+		result->paused_ = paused_;
+
+		return DataHandlePlay::_from_base(result);
+	}
+};
+
+class WaveDataHandle_impl : virtual public DataHandle_impl,
+							virtual public WaveDataHandle_skel
+{
+	GSL::WaveDataHandle wdhandle_;
+
+public:
+	WaveDataHandle_impl() : wdhandle_(GSL::WaveDataHandle::null()) {}
+
+	float mixerFrequency()
+	{
+		return wdhandle_.mixerFrequency();
+	}
+
+	float oscillatorFrequency()
+	{
+		return wdhandle_.oscillatorFrequency();
+	}
+
+	bool load(const string& filename)
+	{
+		return load(filename, 0, 0);
+	}
+
+	bool load(const string& filename,
+			  long waveIndex,
+			  long chunkIndex)
+	{
+		wdhandle_ = GSL::WaveDataHandle(filename, waveIndex, chunkIndex);
+		if(dhandle_.isOpen())
+			dhandle_.close();
+		dhandle_ = wdhandle_;
+		errno_ = dhandle_.isNull() ? 0 : dhandle_.open();
+		return isLoaded();
+	}
+
+	bool isLoaded()
+	{
+		if(wdhandle_.isNull())
+			return false;
+
+		return !wdhandle_.error();
+	}
+
+	DataHandlePlay createPlayer()
+	{
+		DataHandlePlay_impl *result= new DataHandlePlay_impl();
+
+		result->mixerFrequency(mixerFrequency());
+		result->handle(WaveDataHandle::_from_base(this->_copy()));
+
+		return DataHandlePlay::_from_base(result);
+	}
+};
+
+REGISTER_IMPLEMENTATION(DataHandlePlay_impl);
+REGISTER_IMPLEMENTATION(DataHandle_impl);
+REGISTER_IMPLEMENTATION(CroppedDataHandle_impl);
+REGISTER_IMPLEMENTATION(CutDataHandle_impl);
+REGISTER_IMPLEMENTATION(ReversedDataHandle_impl);
+REGISTER_IMPLEMENTATION(WaveDataHandle_impl);
+
+}
diff --git a/flow/fft.c b/flow/fft.c
new file mode 100644
index 0000000..15c821f
--- /dev/null
+++ b/flow/fft.c
@@ -0,0 +1,32 @@
+#include "gsl/gslfft.h"
+#include "fft.h"
+
+void arts_fft_float (
+    unsigned  NumSamples,
+    int       InverseTransform,
+    float    *RealIn,
+    float    *ImagIn,
+    float    *RealOut,
+    float    *ImagOut )
+{
+	double *ri_in = g_newa(double, NumSamples*4);
+	double *ri_out = ri_in + NumSamples*2;
+	unsigned int i;
+
+	for(i = 0; i < NumSamples; i++)
+	{
+		ri_in[2*i] = RealIn[i];
+		ri_in[2*i+1] = (ImagIn?ImagIn[i]:0.0);
+	}
+
+	if(InverseTransform == 0)
+		gsl_power2_fftac (NumSamples, ri_in, ri_out);
+	else
+		gsl_power2_fftsc (NumSamples, ri_in, ri_out);
+
+	for(i = 0; i < NumSamples; i++)
+	{
+		RealOut[i] = ri_out[2*i];
+		ImagOut[i] = ri_out[2*i+1];
+	}
+}
diff --git a/flow/fft.h b/flow/fft.h
new file mode 100644
index 0000000..009f764
--- /dev/null
+++ b/flow/fft.h
@@ -0,0 +1,32 @@
+#ifndef ARTS_FFT_H
+#define ARTS_FFT_H
+
+/*
+ * BC - Status (2002-03-08): arts_fft_float
+ *
+ * This fft interface should be obsoleted in the future in favour of one
+ * exploiting the capabilities of gsl fully. However, it will be kept binary
+ * compatible to avoid everybody to reimplement/duplicate their own fft.
+ */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * performs an fft
+ */
+void arts_fft_float (
+    unsigned  NumSamples,          /* must be a power of 2 */
+    int       InverseTransform,    /* 0=forward FFT, 1=inverse FFT */
+    float    *RealIn,              /* array of input's real samples */
+    float    *ImaginaryIn,         /* array of input's imag samples */
+    float    *RealOut,             /* array of output's reals */
+    float    *ImaginaryOut );      /* array of output's imaginaries */
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* ARTS_FFT_H */
diff --git a/flow/gsl/Makefile.am b/flow/gsl/Makefile.am
new file mode 100644
index 0000000..41a4dab
--- /dev/null
+++ b/flow/gsl/Makefile.am
@@ -0,0 +1,24 @@
+
+EXTRA_DIST =
+CLEANFILES =
+MAINTAINERCLEANFILES =
+
+gslincludedir=$(includedir)/arts/gsl
+include gslmakefile.inc
+
+INCLUDES = -I$(top_srcdir)/flow -I$(top_builddir)/flow -I$(top_srcdir)/mcop -I$(top_builddir)/mcop -I$(top_builddir) $(all_includes)
+AM_CFLAGS = $(GSL_CFLAGS)
+
+noinst_LTLIBRARIES = libgsl.la
+
+libgsl_la_SOURCES = $(GSL_C_SRC) gslfilehash.c gslartsthreads.cc
+libgsl_la_LIBADD = $(top_builddir)/mcop/libmcop.la -lm $(LIBPOSIX4) $(GSL_LIBS) $(LIB_POLL) $(GLIB_LIBADD)
+libgsl_la_LDFLAGS = -no-undefined $(all_libraries)
+
+#noinst_PROGRAMS = $(GSL_NOINST_PROGS)
+
+GSL_progs_ldadd = libgsl.la -lm $(LIBPTHREAD)
+
+GSL_cc_dummy = dummy.cc
+$(srcdir)/dummy.cc: gslconfig.h
+
diff --git a/flow/gsl/arts-patches b/flow/gsl/arts-patches
new file mode 100644
index 0000000..e5bf761
--- /dev/null
+++ b/flow/gsl/arts-patches
@@ -0,0 +1,73 @@
+Those are aRts/KDE-specific changes which won't be backfolded into the
+original GSL repository but are needed here:
+
+--- gsldatahandle-vorbis.c	Tue Jul 30 01:26:06 2002
++++ /usr/src/arts.dh/flow/gsl/gsldatahandle-vorbis.c	Tue Jul 30 17:46:33 2002
+@@ -19,4 +19,5 @@
+ #include "gsldatahandle-vorbis.h"
+ 
++#if GSL_HAVE_OGGVORBIS
+ #include "gslfilehash.h"
+ #include <ogg/ogg.h>
+@@ -239,5 +240,9 @@ read_packet (VorbisHandle *vhandle)
+   
+   vhandle->pcm_pos = ov_pcm_tell (&vhandle->ofile) - vhandle->soffset;
++#if GSL_HAVE_OGGVORBIS_RC3
+   vhandle->pcm_length = ov_read_float (&vhandle->ofile, &pcm, &stream_id);
++#else
++  vhandle->pcm_length = ov_read_float (&vhandle->ofile, &pcm, (~0U>>1), &stream_id);
++#endif
+   if (vhandle->pcm_pos < 0 || vhandle->pcm_length < 0 || stream_id != vhandle->stream)
+     {
+@@ -368,2 +373,4 @@ gsl_data_handle_new_ogg_vorbis (const gc
+     }
+ }
++#endif /* GSL_HAVE_OGGVORBIS */
++
+--- gsldefs.h	Wed Jul 24 05:50:17 2002
++++ /usr/src/arts.dh/flow/gsl/gsldefs.h	Tue Jul 30 02:29:55 2002
+@@ -20,5 +20,8 @@
+ #define __GSL_DEFS_H__
+ 
+-#ifdef	GSL_WANT_GLIB_WRAPPER
++/* configure checks */
++#include <gsl/gslconfig.h>
++
++#if	GSL_USE_GSL_GLIB
+ #include <gsl/gslglib.h>	/* GSL just uses a certain subset of GLib */
+ #else
+@@ -26,9 +29,4 @@
+ #endif
+ 
+-
+-/* configure checks */
+-#include <gsl/gslconfig.h>
+-
+-
+ #ifdef __cplusplus
+ extern "C" {
+@@ -103,5 +101,5 @@ typedef void     (*GslModuleFreeFunc)   
+ 
+ #if defined (BSE_COMPILATION) || defined (BSE_PLUGIN_FALLBACK) \
+-    || defined (GSL_WANT_GLIB_WRAPPER) || defined (GSL_EXTENSIONS)
++    || (GSL_USE_GSL_GLIB) || defined (GSL_EXTENSIONS)
+ #  define if_expect(cond)		if (GSL_GCC_EXPECT (cond))
+ #  define if_reject(cond)		if (GSL_GCC_REJECT (cond))
+--- gslloader-oggvorbis.c	Tue Jul 30 01:26:06 2002
++++ /usr/src/arts.dh/flow/gsl/gslloader-oggvorbis.c	Tue Jul 30 05:06:32 2002
+@@ -19,4 +19,5 @@
+ #include "gsl/gslloader.h"
+ 
++#if GSL_HAVE_OGGVORBIS
+ #include <gsl/gsldatahandle.h>
+ #include "gsldatahandle-vorbis.h"
+@@ -168,2 +169,9 @@ _gsl_init_loader_oggvorbis (void)
+   gsl_loader_register (&loader);
+ }
++#else
++void
++_gsl_init_loader_oggvorbis (void)
++{
++  /* dummy */
++}
++#endif /* GSL_HAVE_OGGVORBIS */
diff --git a/flow/gsl/configure.in.in b/flow/gsl/configure.in.in
new file mode 100644
index 0000000..3b147b9
--- /dev/null
+++ b/flow/gsl/configure.in.in
@@ -0,0 +1,224 @@
+dnl Portability defines that help interoperate with classic and modern autoconfs
+ifdef([AC_TR_SH],[
+define([GLIB_TR_SH],[AC_TR_SH([$1])])
+define([GLIB_TR_CPP],[AC_TR_CPP([$1])])
+], [
+define([GLIB_TR_SH],
+       [patsubst(translit([[$1]], [*+], [pp]), [[^a-zA-Z0-9_]], [_])])
+define([GLIB_TR_CPP],
+       [patsubst(translit([[$1]],
+                          [*abcdefghijklmnopqrstuvwxyz],
+                          [PABCDEFGHIJKLMNOPQRSTUVWXYZ]),
+                 [[^A-Z0-9_]], [_])])
+])
+
+
+dnl GLIB_SIZEOF (INCLUDES, TYPE, ALIAS [, CROSS-SIZE])
+AC_DEFUN([GLIB_SIZEOF],
+[pushdef([glib_Sizeof], GLIB_TR_SH([glib_cv_sizeof_$3]))dnl
+AC_CACHE_CHECK([size of $2], glib_Sizeof,
+[AC_TRY_RUN([#include <stdio.h>
+#if STDC_HEADERS
+#include <stdlib.h>
+#include <stddef.h>
+#endif
+$1
+main()
+{
+  FILE *f=fopen("conftestval", "w");
+  if (!f) exit(1);
+  fprintf(f, "%d\n", sizeof($2));
+  exit(0);
+}],
+  [glib_Sizeof=`cat conftestval`  dnl''
+],
+  [glib_Sizeof=0],
+  ifelse([$4], [], [], [glib_Sizeof=$4]))])
+AC_DEFINE_UNQUOTED(GLIB_TR_CPP(glib_sizeof_$3), [$[]glib_Sizeof], [Size of $3])
+popdef([glib_Sizeof])dnl
+])
+
+AC_DEFUN([AC_GSL_REQUIREMENTS],
+[
+    dnl === Ogg/Vorbis check ===
+    AC_ARG_ENABLE(vorbis,
+    [  --disable-arts-vorbis       disable arts Ogg Vorbis support],
+    [arts_want_vorbis="$enableval"],[arts_want_vorbis="yes"])
+
+    if test "$arts_want_vorbis" = "yes"; then
+        ov_headers=0
+        AC_CHECK_LIB(vorbisfile, ov_read_float,
+          [KDE_CHECK_HEADER(ogg/ogg.h, ov_headers=`expr $ov_headers + 1`)]
+          [KDE_CHECK_HEADER(vorbis/vorbisfile.h, ov_headers=`expr $ov_headers + 1`)]
+          [KDE_CHECK_HEADER(vorbis/vorbisenc.h, ov_headers=`expr $ov_headers + 1`)]
+          ,
+          ov_headers=0, -lvorbisenc -lvorbis -logg)
+        if test $ov_headers = 3 ; then
+          GSL_LIBS="$GSL_LIBS -lvorbisfile -lvorbisenc -lvorbis -logg"
+          GSL_HAVE_OGGVORBIS=1
+        else
+          GSL_HAVE_OGGVORBIS=0
+        fi
+        dnl AC_DEFINE(GSL_HAVE_OGGVORBIS,1,[Define if you want Ogg Vorbis support unconditionally])
+    else
+      GSL_HAVE_OGGVORBIS=0
+      dnl AC_MSG_WARN([failed to detect Ogg/Vorbis library (>=1.0rc3) or headers])
+    fi
+    AC_SUBST(GSL_HAVE_OGGVORBIS)
+
+    dnl check for ov_read_float parameter count (differs in 1.0 vs. rc3)
+    if test $GSL_HAVE_OGGVORBIS = 1; then
+      AC_MSG_CHECKING([for ov_read_float() from rc3])
+      AC_TRY_COMPILE([
+        #include <vorbis/vorbisfile.h>
+      ], [
+        ov_read_float(0,0,0);
+      ], [
+        GSL_HAVE_OGGVORBIS_RC3=1
+        AC_MSG_RESULT(yes)
+      ], [
+        GSL_HAVE_OGGVORBIS_RC3=0
+        AC_MSG_RESULT(no)
+      ])
+      AC_SUBST(GSL_HAVE_OGGVORBIS_RC3)
+    fi
+
+    dnl === libmad MPEG decoder check ===
+    AC_ARG_ENABLE(libmad,
+    [  --disable-libmad       disable arts MAD mp3 decoder support],
+    [arts_want_libmad="$enableval"],[arts_want_libmad="yes"])
+
+    if test "$arts_want_libmad" = "yes"; then
+        mad_detect=0
+        AC_CHECK_LIB(mad, mad_synth_frame,
+          [AC_CHECK_HEADER(mad.h, mad_detect=1)]
+          ,
+          mad_detect=0, -lmad)
+        if test $mad_detect = 1 ; then
+          GSL_LIBS="$GSL_LIBS -lmad"
+          GSL_HAVE_LIBMAD=1
+        else
+          dnl AC_MSG_WARN([failed to detect libmad (MPEG I-III audio decoder) or headers])
+          GSL_HAVE_LIBMAD=0
+        fi
+    else
+      dnl AC_MSG_WARN([failed to detect libmad (MPEG I-III audio decoder) or headers])
+      GSL_HAVE_LIBMAD=0
+    fi
+    AC_SUBST(GSL_HAVE_LIBMAD)
+
+    dnl === Check library requirements ===
+    AC_MSG_CHECKING([the required GSL-Loader library set])
+    if true; then dnl echo $GSL_LIBS | grep ".*-lvorbis.*" >/dev/null ; then
+      AC_MSG_RESULT([complete])
+    else
+      AC_MSG_RESULT([])
+      AC_MSG_ERROR([Ogg/Vorbis is missing, but required])
+    fi
+    AC_SUBST(GSL_LIBS)
+
+    dnl === sizeof types ===
+    GLIB_SIZEOF([#include <pthread.h>], pthread_mutex_t, pth_mutex_t)
+    GSL_SIZEOF_PTH_MUTEX_T="$glib_cv_sizeof_pth_mutex_t"
+    AC_SUBST(GSL_SIZEOF_PTH_MUTEX_T)
+    GLIB_SIZEOF([#include <pthread.h>], pthread_cond_t, pth_cond_t)
+    GSL_SIZEOF_PTH_COND_T="$glib_cv_sizeof_pth_cond_t"
+    AC_SUBST(GSL_SIZEOF_PTH_COND_T)
+    GLIB_SIZEOF([#include <inttypes.h>], intmax_t, std_intmax_t)
+    GSL_SIZEOF_STD_INTMAX_T="$glib_cv_sizeof_std_intmax_t"
+    AC_SUBST(GSL_SIZEOF_STD_INTMAX_T)
+
+    dnl === pthread_mutexattr_settype ===
+    AC_MSG_CHECKING([for pthread_mutexattr_settype()])
+    AC_TRY_COMPILE([
+      #define _XOPEN_SOURCE   500
+      #include <pthread.h>
+    ], [
+      int (*attr_settype) (pthread_mutexattr_t *__attr, int __kind) = pthread_mutexattr_settype;
+      int val = PTHREAD_MUTEX_RECURSIVE;
+      attr_settype = 0; val = 0;
+    ],
+      GSL_HAVE_MUTEXATTR_SETTYPE=1
+      AC_MSG_RESULT(yes)
+    ,
+      GSL_HAVE_MUTEXATTR_SETTYPE=0
+      AC_MSG_RESULT(no)
+    )
+    AC_SUBST(GSL_HAVE_MUTEXATTR_SETTYPE)
+])
+
+AC_DEFUN([AC_GSL_GLIB_REQUIREMENTS],
+[
+	AC_CHECK_FUNCS(getcwd)
+	AC_FUNC_ALLOCA
+
+dnl **********************
+dnl *** va_copy checks ***
+dnl **********************
+dnl we currently check for all three va_copy possibilities, so we get
+dnl all results in config.log for bug reports.
+AC_CACHE_CHECK([for an implementation of va_copy()],glib_cv_va_copy,[
+	AC_TRY_RUN([
+	#include <stdarg.h>
+	void f (int i, ...) {
+	va_list args1, args2;
+	va_start (args1, i);
+	va_copy (args2, args1);
+	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
+	  exit (1);
+	va_end (args1); va_end (args2);
+	}
+	int main() {
+	  f (0, 42);
+	  return 0;
+	}],
+	[glib_cv_va_copy=yes],
+	[glib_cv_va_copy=no],
+	[])
+])
+AC_CACHE_CHECK([for an implementation of __va_copy()],glib_cv___va_copy,[
+	AC_TRY_RUN([
+	#include <stdarg.h>
+	void f (int i, ...) {
+	va_list args1, args2;
+	va_start (args1, i);
+	__va_copy (args2, args1);
+	if (va_arg (args2, int) != 42 || va_arg (args1, int) != 42)
+	  exit (1);
+	va_end (args1); va_end (args2);
+	}
+	int main() {
+	  f (0, 42);
+	  return 0;
+	}],
+	[glib_cv___va_copy=yes],
+	[glib_cv___va_copy=no],
+	[])
+])
+
+if test "x$glib_cv_va_copy" = "xyes"; then
+  g_va_copy_func=va_copy
+else if test "x$glib_cv___va_copy" = "xyes"; then
+  g_va_copy_func=__va_copy
+fi
+fi
+])
+
+AC_GSL_REQUIREMENTS
+AC_GSL_GLIB_REQUIREMENTS
+
+dnl get rid of lots and lots of useless warnings
+
+GSL_CFLAGS="$CFLAGS"
+for warn in -W -Wshadow -pedantic # -Wwrite-strings
+do
+	GSL_CFLAGS="`echo $GSL_CFLAGS | sed 's/ '$warn' / /g'`"
+done
+AC_SUBST(GSL_CFLAGS)
+
+dnl enable aRts version of glib / thread support
+
+GSL_USE_GSL_GLIB=1
+GSL_USE_ARTS_THREADS=1
+AC_SUBST(GSL_USE_GSL_GLIB)
+AC_SUBST(GSL_USE_ARTS_THREADS)
diff --git a/flow/gsl/dummy.cc b/flow/gsl/dummy.cc
new file mode 100644
index 0000000..9fde279
--- /dev/null
+++ b/flow/gsl/dummy.cc
@@ -0,0 +1,3 @@
+/* this is a C++ dummy source to force c++ linkage of the examples */
+
+namespace Arts { int arts_flow_gsl_dummy = 0; }
diff --git a/flow/gsl/gbsearcharray.h b/flow/gsl/gbsearcharray.h
new file mode 100644
index 0000000..df06231
--- /dev/null
+++ b/flow/gsl/gbsearcharray.h
@@ -0,0 +1,292 @@
+/* GBSearchArray - Binary Searchable Array implementation
+ * Copyright (C) 2000-2002 Tim Janik
+ *
+ * This software is provided "as is"; redistribution and modification
+ * is permitted, provided that the following disclaimer is retained.
+ *
+ * This software 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.
+ * In no event shall the authors or contributors be liable for any
+ * direct, indirect, incidental, special, exemplary, or consequential
+ * damages (including, but not limited to, procurement of substitute
+ * goods or services; loss of use, data, or profits; or business
+ * interruption) however caused and on any theory of liability, whether
+ * in contract, strict liability, or tort (including negligence or
+ * otherwise) arising in any way out of the use of this software, even
+ * if advised of the possibility of such damage.
+ */
+#ifndef __G_BSEARCH_ARRAY_H__
+#define __G_BSEARCH_ARRAY_H__
+
+#include <gsl/gsldefs.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* this implementation is intended to be usable in third-party code
+ * simply by pasting the contents of this file. as such, the
+ * implementation needs to be self-contained within this file.
+ */
+
+/* convenience macro to avoid signed overflow for value comparisons */
+#define G_BSEARCH_ARRAY_CMP(v1,v2) ((v1) > (v2) ? +1 : (v1) == (v2) ? 0 : -1)
+
+
+/* --- typedefs --- */
+typedef gint  (*GBSearchCompareFunc) (gconstpointer bsearch_node1, /* key */
+				      gconstpointer bsearch_node2);
+typedef enum
+{
+  G_BSEARCH_ARRAY_ALIGN_POWER2  = 1 << 0, /* memory is power2 aligned */
+  G_BSEARCH_ARRAY_FORCE_SHRINK  = 1 << 1  /* removal shrinks with realloc() */
+} GBSearchArrayFlags;
+
+
+/* --- structures --- */
+typedef struct
+{
+  guint               sizeof_node;
+  GBSearchCompareFunc cmp_nodes;
+  guint               flags;
+} GBSearchConfig;
+typedef union
+{
+  guint    n_nodes;
+  /*< private >*/
+  gpointer alignment_dummy1;
+  glong    alignment_dummy2;
+  gdouble  alignment_dummy3;
+} GBSearchArray;
+
+
+/* --- public API --- */
+static inline GBSearchArray*	g_bsearch_array_create	  (const GBSearchConfig	*bconfig);
+static inline gpointer		g_bsearch_array_get_nth	  (GBSearchArray	*barray,
+							   const GBSearchConfig	*bconfig,
+							   guint		 nth);
+static inline guint		g_bsearch_array_get_index (GBSearchArray	*barray,
+							   const GBSearchConfig	*bconfig,
+							   gconstpointer	 node_in_array);
+static inline GBSearchArray*	g_bsearch_array_remove	  (GBSearchArray	*barray,
+							   const GBSearchConfig	*bconfig,
+							   guint		 index);
+/* preserve uninitialized space at index for node insertion
+ */
+static inline GBSearchArray*	g_bsearch_array_grow	  (GBSearchArray	*barray,
+							   const GBSearchConfig	*bconfig,
+							   guint		 index);
+/* insert key_node into array, or if it exists, replace
+ * the existing node's contents with key_node
+ */
+static inline GBSearchArray*	g_bsearch_array_insert	  (GBSearchArray	*barray,
+							   const GBSearchConfig	*bconfig,
+							   gconstpointer	 key_node);
+static inline void		g_bsearch_array_free	  (GBSearchArray	*barray,
+							   const GBSearchConfig	*bconfig);
+#define	g_bsearch_array_get_n_nodes(barray)	(((GBSearchArray*) (barray))->n_nodes)
+
+/* g_bsearch_array_lookup():
+ * return NULL or exact match node
+ */
+#define	g_bsearch_array_lookup(barray, bconfig, key_node)	\
+    g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 0)
+
+/* g_bsearch_array_lookup_sibling():
+ * return NULL for barray->n_nodes==0, otherwise return the
+ * exact match node, or, if there's no such node, return the
+ * node last visited, which is pretty close to an exact match
+ * (will be one off into either direction).
+ */
+#define	g_bsearch_array_lookup_sibling(barray, bconfig, key_node)	\
+    g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 1)
+
+/* g_bsearch_array_lookup_insertion():
+ * return NULL for barray->n_nodes==0 or exact match, otherwise
+ * return the node where key_node should be inserted (may be one
+ * after end, i.e. g_bsearch_array_get_index(result) <= barray->n_nodes).
+ */
+#define	g_bsearch_array_lookup_insertion(barray, bconfig, key_node)	\
+    g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 2)
+
+
+
+/* --- implementation --- */
+/* helper macro to cut down realloc()s */
+#ifdef  DISABLE_MEM_POOLS
+#define	G_BSEARCH_UPPER_POWER2(n)	(n)
+#else   /* !DISABLE_MEM_POOLS */
+#define G_BSEARCH_UPPER_POWER2(n)       ((n) ? 1 << g_bit_storage ((n) - 1) : 0)
+#endif  /* !DISABLE_MEM_POOLS */
+#define G_BSEARCH_ARRAY_NODES(barray)    (((guint8*) (barray)) + sizeof (GBSearchArray))
+static inline GBSearchArray*
+g_bsearch_array_create (const GBSearchConfig *bconfig)
+{
+  GBSearchArray *barray;
+  guint size;
+
+  g_return_val_if_fail (bconfig != NULL, NULL);
+
+  size = sizeof (GBSearchArray) + bconfig->sizeof_node;
+  if (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2)
+    size = G_BSEARCH_UPPER_POWER2 (size);
+  barray = g_realloc (NULL, size);
+  memset (barray, 0, sizeof (GBSearchArray));
+
+  return barray;
+}
+static inline gpointer
+g_bsearch_array_lookup_fuzzy (GBSearchArray		*barray,
+			      const GBSearchConfig	*bconfig,
+			      gconstpointer		 key_node,
+			      const guint		 sibling_or_after);
+static inline gpointer
+g_bsearch_array_lookup_fuzzy (GBSearchArray        *barray,
+			      const GBSearchConfig *bconfig,
+			      gconstpointer         key_node,
+			      const guint           sibling_or_after)
+{
+  GBSearchCompareFunc cmp_nodes = bconfig->cmp_nodes;
+  guint8 *check = NULL, *nodes = G_BSEARCH_ARRAY_NODES (barray);
+  guint n_nodes = barray->n_nodes, offs = 0;
+  guint sizeof_node = bconfig->sizeof_node;
+  gint cmp = 0;
+
+  while (offs < n_nodes)
+    {
+      guint i = (offs + n_nodes) >> 1;
+
+      check = nodes + i * sizeof_node;
+      cmp = cmp_nodes (key_node, check);
+      if (cmp == 0)
+	return sibling_or_after > 1 ? NULL : check;
+      else if (cmp < 0)
+	n_nodes = i;
+      else /* (cmp > 0) */
+	offs = i + 1;
+    }
+
+  /* check is last mismatch, cmp > 0 indicates greater key */
+  return !sibling_or_after ? NULL : (sibling_or_after > 1 && cmp > 0) ? check + sizeof_node : check;
+}
+static inline gpointer
+g_bsearch_array_get_nth (GBSearchArray        *barray,
+			 const GBSearchConfig *bconfig,
+			 guint                 nth)
+{
+  return (nth < barray->n_nodes ?
+	  G_BSEARCH_ARRAY_NODES (barray) + nth * bconfig->sizeof_node :
+	  NULL);
+}
+static inline guint
+g_bsearch_array_get_index (GBSearchArray        *barray,
+			   const GBSearchConfig *bconfig,
+			   gconstpointer         node_in_array)
+{
+  guint distance = ((guint8*) node_in_array) - G_BSEARCH_ARRAY_NODES (barray);
+
+  g_return_val_if_fail (node_in_array != NULL, barray->n_nodes);
+
+  distance /= bconfig->sizeof_node;
+
+  return MIN (distance, barray->n_nodes + 1); /* may return one after end */
+}
+static inline GBSearchArray*
+g_bsearch_array_grow (GBSearchArray        *barray,
+		      const GBSearchConfig *bconfig,
+		      guint		    index)
+{
+  guint old_size = barray->n_nodes * bconfig->sizeof_node;
+  guint new_size = old_size + bconfig->sizeof_node;
+  guint8 *node;
+
+  g_return_val_if_fail (index <= barray->n_nodes, NULL);
+
+  if (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2)
+    {
+      new_size = G_BSEARCH_UPPER_POWER2 (sizeof (GBSearchArray) + new_size);
+      old_size = G_BSEARCH_UPPER_POWER2 (sizeof (GBSearchArray) + old_size);
+      if (old_size != new_size)
+	barray = g_realloc (barray, new_size);
+    }
+  else
+    barray = g_realloc (barray, sizeof (GBSearchArray) + new_size);
+  node = G_BSEARCH_ARRAY_NODES (barray) + index * bconfig->sizeof_node;
+  g_memmove (node + bconfig->sizeof_node, node, (barray->n_nodes - index) * bconfig->sizeof_node);
+  barray->n_nodes += 1;
+  return barray;
+}
+static inline GBSearchArray*
+g_bsearch_array_insert (GBSearchArray        *barray,
+			const GBSearchConfig *bconfig,
+			gconstpointer         key_node)
+{
+  guint8 *node;
+
+  if (!barray->n_nodes)
+    {
+      barray = g_bsearch_array_grow (barray, bconfig, 0);
+      node = G_BSEARCH_ARRAY_NODES (barray);
+    }
+  else
+    {
+      node = g_bsearch_array_lookup_insertion (barray, bconfig, key_node);
+      if (node)
+	{
+	  guint index = g_bsearch_array_get_index (barray, bconfig, node);
+
+	  /* grow and insert */
+	  barray = g_bsearch_array_grow (barray, bconfig, index);
+	  node = G_BSEARCH_ARRAY_NODES (barray) + index * bconfig->sizeof_node;
+	}
+      else /* replace (relookup is ok, replace is comparatively cheap anyways) */
+	node = g_bsearch_array_lookup (barray, bconfig, key_node);
+    }
+  memcpy (node, key_node, bconfig->sizeof_node);
+  return barray;
+}
+static inline GBSearchArray*
+g_bsearch_array_remove (GBSearchArray        *barray,
+			const GBSearchConfig *bconfig,
+			guint		      index)
+{
+  guint8 *node;
+
+  g_return_val_if_fail (index < barray->n_nodes, NULL);
+
+  barray->n_nodes -= 1;
+  node = G_BSEARCH_ARRAY_NODES (barray) + index * bconfig->sizeof_node;
+  g_memmove (node, node + bconfig->sizeof_node, (barray->n_nodes - index) * bconfig->sizeof_node);
+  if (bconfig->flags & G_BSEARCH_ARRAY_FORCE_SHRINK)
+    {
+      guint new_size = barray->n_nodes * bconfig->sizeof_node;
+      guint old_size = new_size + bconfig->sizeof_node;
+
+      if (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2)
+	{
+	  new_size = G_BSEARCH_UPPER_POWER2 (sizeof (GBSearchArray) + new_size);
+	  old_size = G_BSEARCH_UPPER_POWER2 (sizeof (GBSearchArray) + old_size);
+	  if (old_size != new_size)
+	    barray = g_realloc (barray, new_size);
+	}
+      else
+	barray = g_realloc (barray, sizeof (GBSearchArray) + new_size);
+    }
+  return barray;
+}
+static inline void
+g_bsearch_array_free (GBSearchArray        *barray,
+		      const GBSearchConfig *bconfig)
+{
+  g_return_if_fail (barray != NULL);
+
+  g_free (barray);
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif	/* !__G_BSEARCH_ARRAY_H__ */
diff --git a/flow/gsl/gsl-fftconf.sh b/flow/gsl/gsl-fftconf.sh
new file mode 100755
index 0000000..71f33c3
--- /dev/null
+++ b/flow/gsl/gsl-fftconf.sh
@@ -0,0 +1,468 @@
+#!/bin/sh
+# GSL-GENFFT - Power2 FFT C Code Generator
+# Copyright (C) 2001 Tim Janik
+#
+# 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.
+
+# include files
+echo "#include $2"
+echo "#include <math.h>"
+
+MKFFT="$1"
+IEEE_TYPE="double"
+OPTIONS="--double"
+
+# provide macros and inline stubs
+$MKFFT $OPTIONS 0
+
+#
+# generate small fft sizes, seperating stage 2
+#
+for dir in --analysis --synthesis ; do
+  DOPT="$OPTIONS --skip-macros $dir"
+  echo "Generating FFT functions: $dir" >&2
+  $MKFFT $DOPT	   2 F				# standalone fft2
+  $MKFFT $DOPT	   4 S F			# reusable fft4
+  $MKFFT $DOPT	   4 F X			# standalone fft4
+  $MKFFT $DOPT	   8 s F F			# reusable fft8 w/o input fft2
+  $MKFFT $DOPT	   8 F s X			# standalone fft8
+  $MKFFT $DOPT	  16 s F F F			# reusable fft16
+  $MKFFT $DOPT	  16 F s s X			# standalone fft16
+  $MKFFT $DOPT	  32 s F F F F
+  $MKFFT $DOPT	  32 F s s s X
+  $MKFFT $DOPT	  64 s R R R R F		# reusable fft64
+  $MKFFT $DOPT	  64 F s s s s X		# standalone fft64
+  $MKFFT $DOPT	 128 s R R R R R F		# reusable fft128
+  $MKFFT $DOPT	 128 L s s s s s X		#
+  $MKFFT $DOPT	 256 s s s s s s X T		# reuse fft128
+  $MKFFT $DOPT	 256 L s s s s s s X		#
+  $MKFFT $DOPT	 512 s s s s s s X T T		# reuse fft128
+  $MKFFT $DOPT	 512 L s s s s s s s X		# fft512
+  $MKFFT $DOPT	1024 s s s s s s s s X L	#
+  $MKFFT $DOPT	1024 L s s s s s s s s X	#
+  $MKFFT $DOPT	2048 s s s s s s s s X L L	# reusable fft2048
+  $MKFFT $DOPT	2048 L s s s s s s s s s X	#
+  $MKFFT $DOPT	4096 s s s s s s s s s s X L	# reuses fft2048
+  $MKFFT $DOPT	4096 L s s s s s s s s s s X	# fft4096
+  $MKFFT $DOPT	8192 s s s s s s s s s s s X L	# reusable impl. for 8192, reuses 2048
+  $MKFFT $DOPT	8192 L s s s s s s s s s s s X	# real impl. for 8192
+done
+
+#
+# generic variable length implementation
+#
+echo "Generating generic FFT function for sizes >8192" >&2
+cat <<__EOF
+
+
+/* public FFT frontends and generic handling of huge fft sizes */
+
+
+static void
+gsl_power2_fftc_big (const unsigned int n_values,
+		     const $IEEE_TYPE  *rivalues_in,
+		     $IEEE_TYPE        *rivalues,
+                     const int          esign)
+{
+  const unsigned int n_values2 = n_values << 1;
+  double theta = esign < 0 ? -3.1415926535897932384626433832795029 : 3.1415926535897932384626433832795029;
+  unsigned int i, block_size = 8192 << 1;
+  double last_sin;
+
+  if (esign > 0)
+    {
+      if (rivalues_in)
+        bitreverse_fft2analysis (n_values, rivalues_in, rivalues);
+      for (i = 0; i < n_values; i += 8192)
+        gsl_power2_fft8192analysis_skip2 (rivalues + (i << 1), rivalues + (i << 1));
+    }
+  else
+    {
+      if (rivalues_in)
+        bitreverse_fft2synthesis (n_values, rivalues_in, rivalues);
+      for (i = 0; i < n_values; i += 8192)
+        gsl_power2_fft8192synthesis_skip2 (rivalues + (i << 1), rivalues + (i << 1));
+    }
+  theta *= (double) 1.0 / 8192.;
+  last_sin = sin (theta);
+  
+  /* we're not combining the first and second halves coefficients
+   * in the below loop, since for fft sizes beyond 8192, it'd actually
+   * harm performance due to paging
+   */
+  do
+    {
+      double Dre, Dim, Wre, Wim;
+      unsigned int k, i, half_block = block_size >> 1;
+      unsigned int block_size2 = block_size << 1;
+
+      theta *= 0.5;
+      Dim = last_sin;
+      last_sin = sin (theta);
+      Dre = last_sin * last_sin * -2.;
+      
+      /* loop over first coefficient in each block ==> w == {1,0} */
+      for (i = 0; i < n_values2; i += block_size2)
+	{
+	  unsigned int v1 = i, v2 = i + block_size;
+
+          BUTTERFLY_10 (rivalues[v1], rivalues[v1 + 1],
+                        rivalues[v2], rivalues[v2 + 1],
+                        rivalues[v1], rivalues[v1 + 1],
+                        rivalues[v2], rivalues[v2 + 1],
+                        __1, __0);
+	}
+      Wre = Dre + 1.0;	/* update Wk */
+      Wim = Dim;	/* update Wk */
+      /* loop for every Wk in the first half of each subblock */
+      for (k = 2; k < half_block; k += 2)
+	{
+	  /* loop over kth coefficient in each block */
+	  for (i = k; i < n_values2; i += block_size2)
+	    {
+	      unsigned int v1 = i, v2 = i + block_size;
+	      
+              BUTTERFLY_XY (rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            Wre, Wim);
+	    }
+	  WMULTIPLY (Wre, Wim, Dre, Dim);	/* update Wk */
+	}
+      /* handle middle coefficient ==> w == {0,+-1} */
+      if (k < block_size)
+	{
+	  /* loop over kth coefficient in each block */
+	  if (esign > 0)
+	    for (i = k; i < n_values2; i += block_size2)
+	      {
+	        unsigned int v1 = i, v2 = i + block_size;
+	      
+                BUTTERFLY_01 (rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              __0, __1);
+	      }
+	  else
+	    for (i = k; i < n_values2; i += block_size2)
+	      {
+	        unsigned int v1 = i, v2 = i + block_size;
+	      
+                BUTTERFLY_0m (rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              __0, __1);
+	      }
+	  /* update Wk */
+	  if (esign > 0)
+	    {
+	      Wre = -Dim;
+	      Wim = Dre + 1.0;
+	    }
+	  else
+	    {
+	      Wre = Dim;
+	      Wim = -Dre - 1.0;
+	    }
+	  k += 2;
+	}
+      /* loop for every Wk in the second half of each subblock */
+      for (; k < block_size; k += 2)
+	{
+	  /* loop over kth coefficient in each block */
+	  for (i = k; i < n_values2; i += block_size2)
+	    {
+	      unsigned int v1 = i, v2 = i + block_size;
+
+              BUTTERFLY_XY (rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            Wre, Wim);
+	    }
+	  WMULTIPLY (Wre, Wim, Dre, Dim);	/* update Wk */
+	}
+      block_size = block_size2;
+    }
+  while (block_size <= n_values);
+}
+__EOF
+
+
+#
+# public complex fft frontends
+#
+echo "Generating public complex FFT frontends" >&2
+cat <<__EOF
+void
+gsl_power2_fftac (const unsigned int n_values,
+                  const $IEEE_TYPE  *rivalues_in,
+                  $IEEE_TYPE        *rivalues_out)
+{
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 1);
+  
+  switch (n_values)
+    {
+      case    1: rivalues_out[0] = rivalues_in[0], rivalues_out[1] = rivalues_in[1]; break;
+      case    2: gsl_power2_fft2analysis (rivalues_in, rivalues_out);		break;
+      case    4: gsl_power2_fft4analysis (rivalues_in, rivalues_out);		break;
+      case    8: gsl_power2_fft8analysis (rivalues_in, rivalues_out);		break;
+      case   16: gsl_power2_fft16analysis (rivalues_in, rivalues_out);		break;
+      case   32: gsl_power2_fft32analysis (rivalues_in, rivalues_out);		break;
+      case   64: gsl_power2_fft64analysis (rivalues_in, rivalues_out);		break;
+      case  128: gsl_power2_fft128analysis (rivalues_in, rivalues_out);		break;
+      case  256: gsl_power2_fft256analysis (rivalues_in, rivalues_out);		break;
+      case  512: gsl_power2_fft512analysis (rivalues_in, rivalues_out);		break;
+      case 1024: gsl_power2_fft1024analysis (rivalues_in, rivalues_out);	break;
+      case 2048: gsl_power2_fft2048analysis (rivalues_in, rivalues_out);	break;
+      case 4096: gsl_power2_fft4096analysis (rivalues_in, rivalues_out);	break;
+      case 8192: gsl_power2_fft8192analysis (rivalues_in, rivalues_out);	break;
+      default:	 gsl_power2_fftc_big (n_values, rivalues_in, rivalues_out, +1);
+    }
+}
+void
+gsl_power2_fftsc (const unsigned int n_values,
+                  const $IEEE_TYPE  *rivalues_in,
+                  $IEEE_TYPE        *rivalues_out)
+{
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 1);
+  
+  switch (n_values)
+    {
+      case    1: rivalues_out[0] = rivalues_in[0], rivalues_out[1] = rivalues_in[1]; break;
+      case    2: gsl_power2_fft2synthesis (rivalues_in, rivalues_out);		break;
+      case    4: gsl_power2_fft4synthesis (rivalues_in, rivalues_out);		break;
+      case    8: gsl_power2_fft8synthesis (rivalues_in, rivalues_out);		break;
+      case   16: gsl_power2_fft16synthesis (rivalues_in, rivalues_out);		break;
+      case   32: gsl_power2_fft32synthesis (rivalues_in, rivalues_out);		break;
+      case   64: gsl_power2_fft64synthesis (rivalues_in, rivalues_out);		break;
+      case  128: gsl_power2_fft128synthesis (rivalues_in, rivalues_out);	break;
+      case  256: gsl_power2_fft256synthesis (rivalues_in, rivalues_out);	break;
+      case  512: gsl_power2_fft512synthesis (rivalues_in, rivalues_out);	break;
+      case 1024: gsl_power2_fft1024synthesis (rivalues_in, rivalues_out);	break;
+      case 2048: gsl_power2_fft2048synthesis (rivalues_in, rivalues_out);	break;
+      case 4096: gsl_power2_fft4096synthesis (rivalues_in, rivalues_out);	break;
+      case 8192: gsl_power2_fft8192synthesis (rivalues_in, rivalues_out);	break;
+      default:	 gsl_power2_fftc_big (n_values, rivalues_in, rivalues_out, -1);
+    }
+  /* { unsigned int i; for (i = 0; i < n_values << 1; i++) rivalues_out[i] *= (double) n_values; } */
+}
+__EOF
+
+
+#
+# public real fft frontends
+#
+echo "Generating public real FFT frontends" >&2
+cat <<__EOF
+void
+gsl_power2_fftar (const unsigned int n_values,
+                  const $IEEE_TYPE  *r_values_in,
+                  $IEEE_TYPE        *rivalues_out)
+{
+  unsigned int n_cvalues = n_values >> 1;
+  double Dre, Dim, Wre, Wim, theta;
+  unsigned int i;
+
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 2);
+
+  gsl_power2_fftac (n_cvalues, r_values_in, rivalues_out);
+  theta = 3.1415926535897932384626433832795029;
+  theta /= (double) n_cvalues;
+
+  Dre = sin (0.5 * theta);
+  Dim = sin (theta);
+  Dre = Dre * Dre;
+  Wre = 0.5 - Dre;
+  Dre *= -2.;
+  Wim = Dim * 0.5;
+  for (i = 2; i < n_values >> 1; i += 2)
+    {
+      double F1re, F1im, F2re, F2im, H1re, H1im, H2re, H2im;
+      unsigned int r = n_values - i;
+      double FEre = rivalues_out[i] + rivalues_out[r];
+      double FEim = rivalues_out[i + 1] - rivalues_out[r + 1];
+      double FOre = rivalues_out[r] - rivalues_out[i];
+      double FOim = rivalues_out[r + 1] + rivalues_out[i + 1];
+
+      FEre *= 0.5;
+      FEim *= 0.5;
+      F2re = FOre * Wim;
+      F2im = FOim * Wim;
+      F1re = FOre * Wre;
+      F1im = FOim * Wre;
+
+      H1im = F2im + F1re;
+      H1re = F1im - F2re;
+      H2re = F2re - F1im;
+      H2im = H1im - FEim;
+      H1re += FEre;
+      H2re += FEre;
+      H1im += FEim;
+      rivalues_out[i] = H1re;
+      rivalues_out[i + 1] = H1im;
+      rivalues_out[r] = H2re;
+      rivalues_out[r + 1] = H2im;
+      WMULTIPLY (Wre, Wim, Dre, Dim);
+    }
+  Dre = rivalues_out[0];
+  rivalues_out[0] = Dre + rivalues_out[1];
+  rivalues_out[1] = Dre - rivalues_out[1];
+}
+void
+gsl_power2_fftsr (const unsigned int n_values,
+                  const double      *rivalues_in,
+                  double            *r_values_out)
+{
+  unsigned int n_cvalues = n_values >> 1;
+  double Dre, Dim, Wre, Wim, theta, scale;
+  unsigned int i, ri;
+
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 2);
+
+  theta = -3.1415926535897932384626433832795029;
+  theta /= (double) n_cvalues;
+
+  Dre = sin (0.5 * theta);
+  Dim = sin (theta);
+  Dre = Dre * Dre;
+  Wre = 0.5 - Dre;
+  Dre *= -2.;
+  Wim = Dim * 0.5;
+  for (i = 2, ri = 0; i < n_values >> 1; i += 2)
+    {
+      double F1re, F1im, F2re, F2im, H1re, H1im, H2re, H2im;
+      unsigned int g = n_values - i, j = n_values >> 2, rg = n_values - (ri << 1) - 2;
+      double FEre = rivalues_in[i] + rivalues_in[g];
+      double FEim = rivalues_in[i + 1] - rivalues_in[g + 1];
+      double FOre = rivalues_in[g] - rivalues_in[i];
+      double FOim = rivalues_in[g + 1] + rivalues_in[i + 1];
+
+      while (ri >= j)
+        {
+          ri -= j;
+          j >>= 1;
+        }
+      ri |= j;
+
+      FOre = -FOre;
+      FOim = -FOim;
+      FEre *= 0.5;
+      FEim *= 0.5;
+      F2re = FOre * Wim;
+      F2im = FOim * Wim;
+      F1re = FOre * Wre;
+      F1im = FOim * Wre;
+
+      H1im = F2im + F1re;
+      H1re = F1im - F2re;
+      H2re = F2re - F1im;
+      H2im = H1im - FEim;
+      H1re += FEre;
+      H2re += FEre;
+      H1im += FEim;
+
+      j = ri << 1;
+      r_values_out[j] = H1re;
+      r_values_out[j + 1] = H1im;
+      r_values_out[rg] = H2re;
+      r_values_out[rg + 1] = H2im;
+      WMULTIPLY (Wre, Wim, Dre, Dim);
+    }
+  Dre = rivalues_in[0];
+  r_values_out[0] = Dre + rivalues_in[1];
+  r_values_out[1] = Dre - rivalues_in[1];
+  r_values_out[0] *= 0.5;
+  r_values_out[1] *= 0.5;
+  if (n_values < 4)
+    return;
+  r_values_out[2] = rivalues_in[i];
+  r_values_out[2 + 1] = rivalues_in[i + 1];
+  scale = n_cvalues;
+  scale = 1.0 / scale;
+  for (i = 0; i < n_values; i += 4)
+    BUTTERFLY_10scale (r_values_out[i], r_values_out[i + 1],
+                       r_values_out[i + 2], r_values_out[i + 3],
+                       r_values_out[i], r_values_out[i + 1],
+                       r_values_out[i + 2], r_values_out[i + 3],
+                       scale);
+  switch (n_cvalues)
+    {
+      case    2: break;
+      case    4: gsl_power2_fft4synthesis_skip2 (NULL, r_values_out);	 break;
+      case    8: gsl_power2_fft8synthesis_skip2 (NULL, r_values_out);	 break;
+      case   16: gsl_power2_fft16synthesis_skip2 (NULL, r_values_out);	 break;
+      case   32: gsl_power2_fft32synthesis_skip2 (NULL, r_values_out);	 break;
+      case   64: gsl_power2_fft64synthesis_skip2 (NULL, r_values_out);	 break;
+      case  128: gsl_power2_fft128synthesis_skip2 (NULL, r_values_out);	 break;
+      case  256: gsl_power2_fft256synthesis_skip2 (NULL, r_values_out);	 break;
+      case  512: gsl_power2_fft512synthesis_skip2 (NULL, r_values_out);	 break;
+      case 1024: gsl_power2_fft1024synthesis_skip2 (NULL, r_values_out); break;
+      case 2048: gsl_power2_fft2048synthesis_skip2 (NULL, r_values_out); break;
+      case 4096: gsl_power2_fft4096synthesis_skip2 (NULL, r_values_out); break;
+      case 8192: gsl_power2_fft8192synthesis_skip2 (NULL, r_values_out); break;
+      default:	 gsl_power2_fftc_big (n_cvalues, NULL, r_values_out, -1);
+    }
+}
+void
+gsl_power2_fftar_simple (const unsigned int n_values,
+                         const float       *real_values,
+                         float             *complex_values)
+{
+  double *rv, *cv;
+  guint i;
+
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 2);
+
+  rv = g_new (double, n_values * 2);
+  cv = rv + n_values;
+  i = n_values;
+  while (i--)
+    rv[i] = real_values[i];
+  gsl_power2_fftar (n_values, rv, cv);
+  i = n_values;
+  while (i--)
+    complex_values[i] = cv[i];
+  complex_values[n_values] = complex_values[1];
+  complex_values[1] = 0.0;
+  complex_values[n_values + 1] = 0.0;
+  g_free (rv);
+}
+void
+gsl_power2_fftsr_simple (const unsigned int n_values,
+                         const float       *complex_values,
+                         float             *real_values)
+{
+  double *cv, *rv;
+  guint i;
+
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 2);
+
+  cv = g_new (double, n_values * 2);
+  rv = cv + n_values;
+  i = n_values;
+  while (i--)
+    cv[i] = complex_values[i];
+  cv[1] = complex_values[n_values];
+  gsl_power2_fftsr (n_values, cv, rv);
+  i = n_values;
+  while (i--)
+    real_values[i] = rv[i];
+  g_free (cv);
+}
+__EOF
diff --git a/flow/gsl/gsl-fftgen.pl b/flow/gsl/gsl-fftgen.pl
new file mode 100755
index 0000000..551f8c3
--- /dev/null
+++ b/flow/gsl/gsl-fftgen.pl
@@ -0,0 +1,810 @@
+#!/usr/bin/perl -w
+# GSL-GENFFT - Power2 FFT C Code Generator
+# Copyright (C) 2001 Tim Janik
+#
+# 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.
+    
+# TODO:
+# - optimize L case more
+# - join 2 or 3 stages
+
+my $indent = "  ";
+my $PI = 3.1415926535897932384626433832795029;
+my $ieee_type = "float";
+my $tmp_ieee_type = "double"; # don't change, decreases precision _and_ performance
+
+# arguments
+my $max_fft_size = 0;
+my $gen_macros = 1;
+my $max_unroll = 256;
+my $min_split = 2048;
+my $min_compress = 512;
+my $fft2loop = 0;
+my $single_stage = 0;
+my $negate_sign = 0;
+my $Wtest = 0;
+
+#
+# parse options
+#
+while ($_ = $ARGV[0], defined $_ && /^-/) {
+    shift;
+    last if (/^--$/);
+    if (/^--fft2loop$/) { $fft2loop = 1 }
+    elsif (/^--analysis$/) { $negate_sign = 0 }
+    elsif (/^--synthesis$/) { $negate_sign = 1 }
+    elsif (/^--Wtest$/) { $Wtest = 1 }
+    elsif (/^--double$/) { $ieee_type = "double" }
+    elsif (/^--skip-macros$/) { $gen_macros = 0 }
+    elsif (/^--max-unroll$/) { $max_unroll = shift }
+    elsif (/^--split-at$/) { $min_split = shift }
+    elsif (/^--min-compress$/) { $min_compress = shift }
+    elsif (/^--single-stage$/) { $single_stage = shift }
+}
+# parse arguments
+my @arguments = 0;
+if (defined $ARGV[0]) {
+    $max_fft_size = $ARGV[0];
+    shift;
+}
+while (defined $ARGV[0]) {
+    push @arguments, $ARGV[0];
+    shift;
+}
+
+#
+# check arguments and provide help
+#
+if ($max_fft_size && ($max_fft_size < 2 || $max_fft_size & ($max_fft_size - 1))) {
+    print(STDERR "usage: gsl-genfft [options] <fftsize>\n".
+	  "Produces C code to calculate an FFT of specified <size> which has\n".
+	  "to be a power of 2.\n".
+	  "  --max-unroll <size>   max fft size to unroll loops and bodies\n".
+	  "  --min-compress <size> min fft size to unroll only loop bodies\n".
+	  "  --split-at <size>     max fft size for which recursive ffts are joined\n".
+	  "  --fft2loop            force bitreversing fft2 part into a loop\n".
+	  "");
+    #     "                                                                              |\n"
+    exit 0;
+}
+
+
+#
+# utility functions
+#
+sub bitreverse {
+    my $h = shift;   # fft_size;
+    my $n = shift;
+    my $r = 0;
+
+    while ($n) {
+	$h >>= 1;
+	$r |= $h if ($n & 1);
+	$n >>= 1;
+    }
+    return $r;
+}
+sub Wexponent {
+    my $fft_size = shift;
+    my $n_points = shift;
+    my $nth = shift;      # nth coefficient of this <n_points> stage
+
+    my $r = $nth * $fft_size / $n_points;
+
+    return $r;
+}
+sub Wreal {
+    my $n = shift;   # fft_size
+    my $k = shift;   # power
+
+    my $x = cos ($PI * (2. * $k / $n));
+
+    return $x == 0 ? 0 : $x; # -0.0 == 0
+}
+sub Wimag {
+    my $n = shift;   # fft_size
+    my $k = shift;
+
+    my $x = sin ($PI * (2. * $k / $n));
+    $x = -$x if ($negate_sign);
+
+    return $x == 0 ? 0 : $x; # -0.0 == 0
+}
+
+
+#
+# unrolled fft generation
+#
+sub butterfly {
+    my $type = shift;
+    my $offset1 = shift;
+    my $offset2 = shift;
+    my $Wre = shift;
+    my $Wim = shift;
+    my $var = shift;
+    
+    # define BUTTERFLY_XY(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim,T1re,T1im,T2re,T2im)
+    printf($indent."BUTTERFLY_%s (%s[%s], %s[%s + 1],\n".
+	   $indent."              %s[%s], %s[%s + 1],\n".
+	   $indent."              %s[%s], %s[%s + 1],\n".
+	   $indent."              %s[%s], %s[%s + 1],\n".
+	   $indent."              %s, %s);\n",
+	   $type,
+	   $var, $offset1, $var, $offset1,
+	   $var, $offset2, $var, $offset2,
+	   $var, $offset1, $var, $offset1,
+	   $var, $offset2, $var, $offset2,
+	   $Wre, $Wim);
+}
+sub butterfly_auto {
+  my $fft_size = shift;
+  my $index1 = shift;
+  my $index2 = $index1 + shift;
+  my $wk = shift;
+  my $ofs = shift;
+  my $inplace = shift;
+  my $ib = $inplace ? "Y" : "X";
+  my $rfact = Wreal ($fft_size, $wk);
+  my $ifact = Wimag ($fft_size, $wk);
+  my $index1r = !$inplace ? bitreverse ($fft_size, $index1 >> 1) << 1 : $index1;
+  my $index2r = !$inplace ? bitreverse ($fft_size, $index2 >> 1) << 1 : $index2;
+  my $btype = "XY";
+  my $optimize_10 = $wk == 0;
+  my $optimize_0x = $wk == $fft_size / 4;
+
+  if (abs ($rfact - 1.0) < 0.0000000000000005 &&
+      abs ($ifact - 0.0) < 0.0000000000000005) {
+      $btype = "10";
+      # print STDERR "10: ". $wk ."\n";
+      $optimize_10 = 0 if ($optimize_10);
+  } elsif (abs ($rfact - 0.0) < 0.0000000000000005 &&
+	   abs ($ifact - 1.0) < 0.0000000000000005) {
+      $btype = "01";
+      # print STDERR "01: ". $wk ."\n";
+      $optimize_0x = 0 if ($optimize_0x);
+  } elsif (abs ($rfact - 0.0) < 0.0000000000000005 &&
+	   abs ($ifact + 1.0) < 0.0000000000000005) {
+      $btype = "0m";
+      # print STDERR "0m: ". $wk ."\n";
+      $optimize_0x = 0 if ($optimize_0x);
+  } elsif (abs ($rfact - $ifact) < 0.0000000000000005) {
+      $btype = "XX";  # grr, this actually slows down the athlon (keep "XY")
+  } elsif (abs ($rfact + $ifact) < 0.0000000000000005) {
+      $btype = "yY";  # grr, this actually slows down the athlon (keep "XY")
+  }
+
+  if ($optimize_10 || $optimize_0x) {
+      die("optimization error for fft$fft_size: 10=". $optimize_10 .", 0x=". $optimize_0x .
+	  ", Wre=". $rfact ." Wim=". $ifact .", wk=". $wk);
+  }
+  
+  # BUTTERFLY_XY (X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim,T1re,T1im,T2re,T2im);
+  printf($indent."BUTTERFLY_%s (%s[%s%u],               /* W%u */\n".
+	 $indent."              %s[%s%u + 1],\n".
+	 $indent."              %s[%s%u],\n".
+	 $indent."              %s[%s%u + 1],\n".
+	 $indent."              Y[%s%u],\n".
+	 $indent."              Y[%s%u + 1],\n".
+	 $indent."              Y[%s%u],\n".
+	 $indent."              Y[%s%u + 1],\n".
+	 $indent."              (%s) %+.15f, (%s) %+.15f);\n",
+	 $btype,
+	 $ib, $ofs, $index1r, $wk, $ib, $ofs, $index1r, $ib, $ofs, $index2r, $ib, $ofs, $index2r,
+	 $ofs, $index1, $ofs, $index1, $ofs, $index2, $ofs, $index2,
+	 $tmp_ieee_type, $rfact, $tmp_ieee_type, $ifact);
+}
+sub unroll_stage {
+    my $fft_size = shift;
+    my $n_points = shift;
+    my $n_rep = shift;     # repetitions
+    my $unroll_outer = shift;
+    
+    if ($unroll_outer && $n_points == 2) {
+	for (my $i = 0; $i < $n_points >> 1; $i++) {
+	    for (my $j = 0; $j < $n_rep; $j++) {
+		my $offset1 = ($j * $n_points + $i) * 2;
+		my $offset2 = $offset1 + $n_points;
+		my $offset1r = bitreverse ($fft_size, $offset1 >> 1) << 1;
+		my $offset2r = bitreverse ($fft_size, $offset2 >> 1) << 1;
+		my $scale = !$negate_sign ? "__1, __0" : sprintf "1.0 / (%s) %u", $tmp_ieee_type, $fft_size;
+		printf($indent."BUTTERFLY_10%s (X[%s], X[%s + 1],\n".
+		       $indent."                X[%s], X[%s + 1],\n".
+		       $indent."                Y[%s], Y[%s + 1],\n".
+		       $indent."                Y[%s], Y[%s + 1],\n".
+		       $indent."                %s);\n",
+		       $negate_sign ? "scale" : "",
+		       $offset1r, $offset1r,
+		       $offset2r, $offset2r,
+		       $offset1, $offset1,
+		       $offset2, $offset2,
+		       $scale);
+	    }
+	}
+    } elsif ($unroll_outer) {
+	for (my $i = 0; $i < $n_points >> 1; $i++) {
+	    for (my $j = 0; $j < $n_rep; $j++) {
+		butterfly_auto ($fft_size,
+				($j * $n_points + $i) * 2,
+				$n_points,
+				Wexponent ($fft_size, $n_points, $i),
+				"", $n_points != 2);
+	    }
+	}
+    } else {
+	die "cannot skip outer loop unrolling for fft2" if $n_points == 2;
+	
+	printf "%sfor (block = 0; block < %u; block += %u) {\n", $indent, $n_points * 2 * $n_rep, $n_points * 2;
+	$indent .= "  ";
+	for (my $i = 0; $i < $n_points >> 1; $i++) {
+	    butterfly_auto ($fft_size,
+			    $i * 2,
+			    $n_points,
+			    Wexponent ($fft_size, $n_points, $i),
+			    "block + ", $n_points != 2);
+	}
+	$indent =~ s/\ \ $//;
+	printf "%s}\n", $indent;
+    }
+}
+sub table_stage {
+    my $fft_size = shift;
+    my $n_points = shift;
+    my $n_rep = shift;     # repetitions
+    
+    die "cannot loop over coefficient table for fft2" if $n_points == 2;
+
+    printf "%s{\n", $indent;
+    $indent .= "  ";
+    printf "%sstatic const %s Wconst%u[] = {\n", $indent, $tmp_ieee_type, $n_points;
+    for (my $i = 1; $i < $n_points >> 2; $i++) {
+	my $wk = Wexponent ($fft_size, $n_points, $i);
+	printf "%s  %+.15f, %+.15f,\n", $indent, Wreal ($fft_size, $wk), Wimag ($fft_size, $wk);
+    }
+    printf "%s};\n", $indent;
+    printf "%sconst %s *W = Wconst%u - 2;\n", $indent, $tmp_ieee_type, $n_points;
+    printf "%s%s *Z = Y + %u;\n", $indent, $ieee_type, $n_points >> 1;
+
+    # first half loops
+    printf("%sfor (offset = 0; offset < %u; offset += %u) {\n",
+	   $indent, $n_points * 2 * $n_rep, $n_points * 2);
+    $indent .= "  ";
+    $ofs2 = sprintf "offset + %u", $n_points;
+    butterfly ("10", "offset", $ofs2, "__1", "__0", "Y");
+    butterfly ($negate_sign ? "0m" : "01", "offset", $ofs2, "__0", "__1", "Z");
+    $indent =~ s/\ \ $//;
+    printf "%s}\n", $indent;
+    printf "%sfor (butterfly = 2; butterfly < %u; butterfly += 2) {\n", $indent, $n_points >> 1;
+    printf "%s  Wre = W[butterfly]; Wim = W[butterfly + 1];\n", $indent;
+    printf "%s  for (block = 0; block < %u; block += %u) {\n", $indent, $n_points * 2 * $n_rep, $n_points * 2;
+    $indent .= "    ";
+    printf "%soffset = butterfly + block;\n", $indent;
+    $ofs2 = sprintf "offset + %u", $n_points;
+    butterfly ("XY", "offset", $ofs2, "Wre", "Wim", "Y");
+    butterfly ($negate_sign ? "yX" : "Yx", "offset", $ofs2, "Wre", "Wim", "Z");
+    $indent =~ s/\ \ \ \ $//;
+    printf "%s  }\n", $indent;
+    printf "%s}\n", $indent;
+
+    # second half loops
+    if (0) {
+	printf("%sfor (offset = %u; offset < %u + %u; offset += %u) {\n",
+	       $indent, $n_points >> 1, $n_points >> 1, $n_points * 2 * $n_rep, $n_points * 2);
+	$indent .= "  ";
+	$ofs2 = sprintf "offset + %u", $n_points;
+	butterfly ($negate_sign ? "0m" : "01", "offset", $ofs2, "__0", "__1", "Y");
+	$indent =~ s/\ \ $//;
+	printf "%s}\n", $indent;
+	printf "%sW -= %u;\n", $indent, $n_points >> 1;
+	printf "%sfor (butterfly = %u + 2; butterfly < %u; butterfly += 2) {\n", $indent, $n_points >> 1, $n_points;
+	printf "%s  Wre = W[butterfly]; Wim = W[butterfly + 1];\n", $indent;
+	printf "%s  for (block = 0; block < %u; block += %u) {\n", $indent, $n_points * 2 * $n_rep, $n_points * 2;
+	$indent .= "    ";
+	printf "%soffset = butterfly + block;\n", $indent;
+	$ofs2 = sprintf "offset + %u", $n_points;
+	butterfly ($negate_sign ? "yX" : "Yx", "offset", $ofs2, "Wre", "Wim", "Y");
+	$indent =~ s/\ \ \ \ $//;
+	printf "%s  }\n", $indent;
+	printf "%s}\n", $indent;
+    }
+    
+    $indent =~ s/\ \ $//;
+    printf "%s}\n", $indent;
+}
+sub bitreverse_fft2 {
+    # mul_result = gsl_complex (c1.re * c2.re - c1.im * c2.im, c1.re * c2.im + c1.im * c2.re);
+    printf "
+static inline void
+bitreverse_fft2analysis (const unsigned int n,
+                         const %-6s        *X,
+                         %-6s              *Y)
+{
+  const unsigned int n2 = n >> 1, n1 = n + n2, max = n >> 2;
+  unsigned int i, r;
+  
+  BUTTERFLY_10 (X[0], X[1],
+		X[n], X[n + 1],
+		Y[0], Y[1],
+		Y[2], Y[3],
+		__1, __0);
+  BUTTERFLY_10 (X[n2], X[n2 + 1],
+		X[n1], X[n1 + 1],
+		Y[4], Y[5],
+		Y[6], Y[7],
+		__1, __0);
+  for (i = 1, r = 0; i < max; i++)
+    {
+      unsigned int k, j = n >> 1;
+
+      while (r >= j)
+	{
+	  r -= j;
+	  j >>= 1;
+	}
+      r |= j;
+
+      k = r >> 1;
+      j = i << 3;
+      BUTTERFLY_10 (X[k], X[k + 1],
+		    X[k + n], X[k + n + 1],
+		    Y[j], Y[j + 1],
+		    Y[j + 2], Y[j + 3],
+		    __1, __0);
+      k += n2;
+      j += 4;
+      BUTTERFLY_10 (X[k], X[k + 1],
+		    X[k + n], X[k + n + 1],
+		    Y[j], Y[j + 1],
+		    Y[j + 2], Y[j + 3],
+		    __1, __0);
+    }
+}
+static inline void
+bitreverse_fft2synthesis (const unsigned int n,
+                          const %-6s        *X,
+                          %-6s              *Y)
+{
+  const unsigned int n2 = n >> 1, n1 = n + n2, max = n >> 2;
+  unsigned int i, r;
+  %s scale = n;
+
+  scale = 1.0 / scale;
+  BUTTERFLY_10scale (X[0], X[1],
+		     X[n], X[n + 1],
+		     Y[0], Y[1],
+		     Y[2], Y[3],
+		     scale);
+  BUTTERFLY_10scale (X[n2], X[n2 + 1],
+		     X[n1], X[n1 + 1],
+		     Y[4], Y[5],
+		     Y[6], Y[7],
+		     scale);
+  for (i = 1, r = 0; i < max; i++)
+    {
+      unsigned int k, j = n >> 1;
+
+      while (r >= j)
+	{
+	  r -= j;
+	  j >>= 1;
+	}
+      r |= j;
+
+      k = r >> 1;
+      j = i << 3;
+      BUTTERFLY_10scale (X[k], X[k + 1],
+			 X[k + n], X[k + n + 1],
+			 Y[j], Y[j + 1],
+			 Y[j + 2], Y[j + 3],
+			 scale);
+      k += n2;
+      j += 4;
+      BUTTERFLY_10scale (X[k], X[k + 1],
+			 X[k + n], X[k + n + 1],
+			 Y[j], Y[j + 1],
+			 Y[j + 2], Y[j + 3],
+			 scale);
+    }
+}
+", $ieee_type, $ieee_type, $ieee_type, $ieee_type, $tmp_ieee_type;
+
+    # testing:
+    # define BUTTERFLY_10(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim,T1re,T1im,T2re,T2im) \
+    #  { int a = &X1re-X, b = &X2re-X, c = &Y1re-Y; \
+    #    printf ("bufferfly: [%u,%u] -> [%u,%u]\n", (a)>>1, (b)>>1, (c)>>1, (c+2)>>1); \
+    #    if (((a)|(b)|(c))&1) perror("****eek, extraneous bits!");}
+    # int main (int argc, char *argv[]) {
+    #   bitreverse_fft2a (atoi (argv[1]), 0, 0);
+    #     return 0;
+    # }
+}
+
+#
+# fft generation routines
+#
+sub gen_fft_loop_unoptimized {
+    my $fft_size = shift;
+    my $n_points = shift;
+    my $n_rep = shift;     # repetitions
+    my $ofs2;
+    
+    die "invalid fft size: " . $n_points if ($n_points < 4);
+
+    # incremental coefficient W for this fft
+    my $theta = $PI / ($n_points >> 1);
+    $theta = -$theta if ($negate_sign);
+    my $re = sin (0.5 * $theta);
+    my $im = sin ($theta);
+    $re = $re * $re * -2.;
+    
+    # init variables, start loops
+    printf "%sWre = 1.0; Wim = 0.0;\n", $indent;
+    printf "%sfor (butterfly = 0; butterfly < %u; butterfly += 2) {\n", $indent, $n_points;
+    $indent .= "  ";
+    printf "%sfor (block = 0; block < %u; block += %u) {\n", $indent, $n_rep * $n_points << 1, $n_points << 1;
+    $indent .= "  ";
+
+    # do the butterfly
+    printf "%soffset = butterfly + block;\n", $indent;
+    $ofs2 = sprintf "offset + %u", $n_points;
+    butterfly ("XY", "offset", $ofs2, "Wre", "Wim", "Y");
+
+    # close inner loop, update W
+    $indent =~ s/\ \ $//;
+    printf "%s}\n", $indent;
+    printf("%sWMULTIPLY (Wre, Wim, %+.15f, %+.15f);\n",
+	   $indent, $re, $im);
+
+    # close outer loop, done
+    $indent =~ s/\ \ $//;
+    printf "%s}\n", $indent;
+}
+sub gen_fft_loop_o10o0x {
+    my $fft_size = shift;
+    my $n_points = shift;
+    my $n_rep = shift;     # repetitions
+    my $ofs2;
+    
+    die "invalid fft size: " . $n_points if ($n_points < 4);
+
+    # coefficient {1,0} loop
+    printf "%sfor (offset = 0; offset < %u; offset += %u) {\n", $indent, $n_rep * $n_points << 1, $n_points << 1;
+    $indent .= "  ";
+    $ofs2 = sprintf "offset + %u", $n_points;
+    butterfly ("10", "offset", $ofs2, "__1", "__0", "Y");
+    $indent =~ s/\ \ $//;
+    printf "%s}\n", $indent;
+
+    # incremental coefficient W for this fft
+    my $theta = $PI / ($n_points >> 1);
+    $theta = -$theta if ($negate_sign);
+    my $re = sin (0.5 * $theta);
+    my $im = sin ($theta);
+    $re = $re * $re * -2.;
+    
+    # loop first half
+    if (2 < $n_points >> 1) {
+	printf "%sWre = %+.15f; Wim = %+.15f;\n", $indent, $re + 1.0, $im;
+	printf "%sfor (butterfly = 2; butterfly < %u; butterfly += 2) {\n", $indent, $n_points >> 1;
+	$indent .= "  ";
+	printf "%sfor (block = 0; block < %u; block += %u) {\n", $indent, $n_rep * $n_points << 1, $n_points << 1;
+	$indent .= "  ";
+	# do the butterfly
+	printf "%soffset = butterfly + block;\n", $indent;
+	$ofs2 = sprintf "offset + %u", $n_points;
+	butterfly ("XY", "offset", $ofs2, "Wre", "Wim", "Y");
+	# close inner loop, update W
+	$indent =~ s/\ \ $//;
+	printf "%s}\n", $indent;
+	printf("%sWMULTIPLY (Wre, Wim, %+.15f, %+.15f);\n",
+	       $indent, $re, $im);
+	# close outer loop, done
+	$indent =~ s/\ \ $//;
+	printf "%s}\n", $indent;
+    }
+    
+    # coefficient {0,1} loop
+    printf "%sfor (offset = %u; offset < %u; offset += %u) {\n", $indent, $n_points >> 1, $n_rep * $n_points << 1, $n_points << 1;
+    $indent .= "  ";
+    $ofs2 = sprintf "offset + %u", $n_points;
+    butterfly ($negate_sign ? "0m" : "01", "offset", $ofs2, "__0", "__1", "Y");
+    $indent =~ s/\ \ $//;
+    printf "%s}\n", $indent;
+
+    # loop second half
+    if (($n_points >> 1) + 2 < $n_points) {
+	if ($negate_sign) {
+            printf "%sWre = %+.15f; Wim = %+.15f;\n", $indent, $im, -$re - 1.0;
+	} else {
+	    printf "%sWre = %+.15f; Wim = %+.15f;\n", $indent, -$im, $re + 1.0;
+	}
+	printf "%sfor (butterfly = %u; butterfly < %u; butterfly += 2) {\n", $indent, ($n_points >> 1) + 2, $n_points;
+	$indent .= "  ";
+	printf "%sfor (block = 0; block < %u; block += %u) {\n", $indent, $n_rep * $n_points << 1, $n_points << 1;
+	$indent .= "  ";
+	# do the butterfly
+	printf "%soffset = butterfly + block;\n", $indent;
+	$ofs2 = sprintf "offset + %u", $n_points;
+	butterfly ("XY", "offset", $ofs2, "Wre", "Wim", "Y");
+	# close inner loop, update W
+	$indent =~ s/\ \ $//;
+	printf "%s}\n", $indent;
+	printf("%sWMULTIPLY (Wre, Wim, %+.15f, %+.15f);\n",
+	       $indent, $re, $im);
+	# close outer loop, done
+	$indent =~ s/\ \ $//;
+	printf "%s}\n", $indent;
+    }
+}
+sub fft_loop_macros {
+    # mul_result = gsl_complex (c1.re * c2.re - c1.im * c2.im, c1.re * c2.im + c1.im * c2.re);
+    print "
+#define WMULTIPLY(Wre,Wim,Dre,Dim) { \\
+  register $tmp_ieee_type T1re, T1im, T2re, T2im; \\
+  T1re = Wre * Dre;  \\
+  T1im = Wim * Dre;  \\
+  T2re = Wim * Dim;  \\
+  T2im = Wre * Dim;  \\
+  T1re -= T2re;      \\
+  T1im += T2im;      \\
+  Wre += T1re;       \\
+  Wim += T1im;       \\
+}";
+}
+sub butterfly_macros {
+    # mul_result = gsl_complex (c1.re * c2.re - c1.im * c2.im, c1.re * c2.im + c1.im * c2.re);
+    # add_result = gsl_complex (c1.re + c2.re, c1.im + c2.im);
+    print "
+#define BUTTERFLY_XY(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim) { \\
+  register $tmp_ieee_type T1re, T1im, T2re, T2im; \\
+  T1re = X2re * Wre;  \\
+  T1im = X2im * Wre;  \\
+  T2re = X2im * Wim;  \\
+  T2im = X2re * Wim;  \\
+  T1re -= T2re;       \\
+  T1im += T2im;       \\
+  T2re = X1re - T1re; \\
+  T2im = X1im - T1im; \\
+  Y1re = X1re + T1re; \\
+  Y1im = X1im + T1im; \\
+  Y2re = T2re;        \\
+  Y2im = T2im;        \\
+}
+#define BUTTERFLY_Yx(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim) { \\
+  register $tmp_ieee_type T1re, T1im, T2re, T2im; \\
+  T1re = X2re * Wim;  \\
+  T1im = X2im * Wim;  \\
+  T2re = X2im * Wre;  \\
+  T2im = X2re * Wre;  \\
+  T1re += T2re;       \\
+  T1im -= T2im;       \\
+  T2re = X1re + T1re; \\
+  T2im = X1im + T1im; \\
+  Y1re = X1re - T1re; \\
+  Y1im = X1im - T1im; \\
+  Y2re = T2re;        \\
+  Y2im = T2im;        \\
+}
+#define BUTTERFLY_yX(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim) { \\
+  register $tmp_ieee_type T1re, T1im, T2re, T2im; \\
+  T1re = X2re * Wim;  \\
+  T1im = X2im * Wim;  \\
+  T2re = X2im * Wre;  \\
+  T2im = X2re * Wre;  \\
+  T1re += T2re;       \\
+  T1im -= T2im;       \\
+  T2re = X1re - T1re; \\
+  T2im = X1im - T1im; \\
+  Y1re = X1re + T1re; \\
+  Y1im = X1im + T1im; \\
+  Y2re = T2re;        \\
+  Y2im = T2im;        \\
+}
+#define BUTTERFLY_10(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \\
+  register $tmp_ieee_type T2re, T2im; \\
+  T2re = X1re - X2re; \\
+  T2im = X1im - X2im; \\
+  Y1re = X1re + X2re; \\
+  Y1im = X1im + X2im; \\
+  Y2re = T2re;        \\
+  Y2im = T2im;        \\
+}
+#define BUTTERFLY_01(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \\
+  register $tmp_ieee_type T2re, T2im; \\
+  T2re = X1re + X2im; \\
+  T2im = X1im - X2re; \\
+  Y1re = X1re - X2im; \\
+  Y1im = X1im + X2re; \\
+  Y2re = T2re;        \\
+  Y2im = T2im;        \\
+}
+#define BUTTERFLY_0m(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \\
+  register $tmp_ieee_type T2re, T2im; \\
+  T2re = X1re - X2im; \\
+  T2im = X1im + X2re; \\
+  Y1re = X1re + X2im; \\
+  Y1im = X1im - X2re; \\
+  Y2re = T2re;        \\
+  Y2im = T2im;        \\
+}
+#define BUTTERFLY_XX(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,_2) { \\
+  register $tmp_ieee_type T1re, T1im, T2re, T2im; \\
+  T1re = X2re * Wre;  \\
+  T1im = X2im * Wre;  \\
+  T2re = T1im; \\
+  T2im = T1re; \\
+  T1re -= T2re;       \\
+  T1im += T2im;       \\
+  T2re = X1re - T1re; \\
+  T2im = X1im - T1im; \\
+  Y1re = X1re + T1re; \\
+  Y1im = X1im + T1im; \\
+  Y2re = T2re;        \\
+  Y2im = T2im;        \\
+}
+#define BUTTERFLY_yY(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,_2) { \\
+  register $tmp_ieee_type T1re, T1im, T2re, T2im; \\
+  T1re = X2re * Wre;  \\
+  T1im = X2im * Wre;  \\
+  T2re = T1im;  \\
+  T2im = T1re;  \\
+  T1re += T2re;       \\
+  T1im -= T2im;       \\
+  T2re = X1re - T1re; \\
+  T2im = X1im - T1im; \\
+  Y1re = X1re + T1re; \\
+  Y1im = X1im + T1im; \\
+  Y2re = T2re;        \\
+  Y2im = T2im;        \\
+}
+#define BUTTERFLY_10scale(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,S) { \\
+  register $tmp_ieee_type T2re, T2im; \\
+  T2re = X1re - X2re; \\
+  T2im = X1im - X2im; \\
+  Y1re = X1re + X2re; \\
+  Y1im = X1im + X2im; \\
+  Y2re = T2re * S;    \\
+  Y2im = T2im * S;    \\
+  Y1re *= S;          \\
+  Y1im *= S;          \\
+}
+";
+}
+
+
+#
+# stage generation
+#
+sub gen_stage {
+    my $fft_size = shift;
+    my $n_points = shift;
+    my $kind = shift;
+    my $times = $fft_size / $n_points;
+    
+    if ($kind eq 'S') {
+	printf "\n%s/* skipping %u times fft%u */\n", $indent, $times, $n_points;
+	return;
+    }
+    if ($n_points == 2) {   # input stage needs special handling
+	if ($kind eq 'L') {
+	    printf "\n%s/* perform fft2 and bitreverse input */\n", $indent;
+	    printf "%sbitreverse_fft2%s (%u, X, Y);\n", $indent, $negate_sign ? "synthesis" : "analysis", $fft_size;
+	} elsif ($kind eq 'F') {
+	    printf "\n%s/* perform %u times fft2 */\n", $indent, $times;
+	    unroll_stage ($fft_size, $n_points, $times, 1);
+	} else {
+	    die "need one of 'L' or 'F' for input stage";
+	}
+    } else {
+	if ($kind eq 'L') {
+            printf "\n%s/* perform %u times fft%u */\n", $indent, $times, $n_points;
+	    gen_fft_loop_o10o0x ($fft_size, $n_points, $times);
+	} elsif ($kind eq 'F') {
+            printf "\n%s/* perform %u times fft%u */\n", $indent, $times, $n_points;
+	    unroll_stage ($fft_size, $n_points, $times, 1);
+	} elsif ($kind eq 'R') {
+            printf "\n%s/* perform %u times fft%u */\n", $indent, $times, $n_points;
+	    unroll_stage ($fft_size, $n_points, $times, $times == 1);
+	} elsif ($kind eq 'T') {
+            printf "\n%s/* perform %u times fft%u */\n", $indent, $times, $n_points;
+	    table_stage ($fft_size, $n_points, $times);
+	} elsif ($kind eq 'X') {
+            printf "\n%s/* perform %u times fft%u */\n", $indent, $times, $n_points;
+	    for (my $i = 0; $i < $times; $i++) {
+		if ($i) {
+		    printf($indent."gsl_power2_fft%u%s_skip2 (X + %u, Y + %u);\n",
+			   $n_points, $negate_sign ? "synthesis" : "analysis", $n_points * $i << 1, $n_points * $i << 1);
+		} else {
+		    printf($indent."gsl_power2_fft%u%s_skip2 (X, Y);\n",
+			   $n_points, $negate_sign ? "synthesis" : "analysis");
+		}
+	    }
+	} else {
+	    die "unknown kind: $kind";
+	}
+    }
+}
+
+#
+# test output
+#
+if ($Wtest) {
+    my $fft_size = $max_fft_size;
+    
+    for (my $i = 0; $i < $fft_size >> 1; $i++) {
+	my $wk = Wexponent ($fft_size, $fft_size, $i);
+	printf "$fft_size: %4u:  %+.15f, %+.15f,\n", $i, Wreal ($fft_size, $wk), Wimag ($fft_size, $wk);
+    }
+    exit 0;
+}
+if (0) {
+    # reversal test
+    for (my $i = 0; $i < $fft_size; $i++) {
+	printf STDERR "%-3u <-> %3u   %s\n", $i, bitreverse ($fft_size, $i), $i % 4 ? "" : "XXX";
+    }
+}
+
+
+#
+# main output
+#
+if ($gen_macros) {
+    butterfly_macros ();
+    fft_loop_macros ();
+    bitreverse_fft2 ();
+}
+exit 0 if (!$max_fft_size);
+
+my $max_stages = 0;
+for ($i = $max_fft_size >> 1; $i; $i >>= 1) {
+    $max_stages++;
+}
+die "missing stage specifications ($max_stages stages, $#arguments specs)" if ($max_stages > $#arguments);
+die "too many stage specifications ($max_stages stages, $#arguments specs)" if ($max_stages < $#arguments);
+print "/**\n";
+printf(" ** Generated data (by gsl-genfft $max_fft_size");
+for (my $i = 1; $i < @arguments; $i++) {
+    printf " %s", uc ($arguments[$i]);
+}
+printf ")\n";
+print " **/\n";
+{
+    my $fft_size = $max_fft_size;
+    my $skip2 = uc ($arguments[1]) eq 'S';
+
+    printf STDERR "FFT-%-5u: ", $fft_size;
+    
+    printf "static void\n";
+    printf("gsl_power2_fft%u%s%s (const %s *X, %s *Y)\n{\n",
+	   $fft_size, $negate_sign ? "synthesis" : "analysis",
+	   $skip2 ? "_skip2" : "",
+	   $ieee_type, $ieee_type);
+    printf "%sregister unsigned int butterfly, block, offset;\n", $indent;
+    printf "%sregister %s Wre, Wim;\n\n", $indent, $tmp_ieee_type, $tmp_ieee_type;
+    printf "%sbutterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */\n", $indent;
+    
+    my $seen_rule = 0;
+    for (my $i = 1; $i < @arguments && 1 << $i <= $fft_size; $i++) {
+	my $stage = uc ($arguments[$i]);
+	printf STDERR "%u-%s ", 1 << $i, $stage;
+	die "X follows non Skip" if ($stage eq "X" && $seen_rule);
+	gen_stage ($fft_size, 1 << $i, $stage);
+	$seen_rule |= (1 << $i) > 2 && !($stage eq "S");
+    }
+    printf "}\n";
+    printf STDERR "\n";
+}
+print "\n/**\n";
+print " ** Generated data ends here\n";
+print " **/\n";
diff --git a/flow/gsl/gsl-iplan.txt b/flow/gsl/gsl-iplan.txt
new file mode 100644
index 0000000..e37b55d
--- /dev/null
+++ b/flow/gsl/gsl-iplan.txt
@@ -0,0 +1,57 @@
+How to integrate the GSL engine into artsd?
+
+Open issues:
+ - adapting the driver model
+ - adapting main loop callbacks
+ - adapting the start()/stop() semantics
+ - multi streams
+ - midi/audio timing
+ - synchronization
+ - threadsafe module api
+ - how to live without the threading layer
+
+[*] adapting main loop callbacks
+
+the engine uses a three-state mainloop callback, which consists of
+
+1. prepare
+2. check
+3. dispatch
+
+with the following rules applying
+
+1. you always need to prepare, to obtain pollfds
+2. you check to see whether something needs to be done
+3. you dispatch to make the engine do something
+
+which will need to be treated in aRts as two state strategy, which is:
+================================================================================
+INIT:
+  prepare -> register fds with the IOManager
+--
+ON NOTIFY:
+  unregister fds with the IOManager
+
+  reselect all fds
+  check -> check if engine needs work
+  dispatch -> make engine do something
+
+  prepare -> reregister fds with the IOManager
+
+as temporary measure, we could eventually build an imaginary fd into the
+engine, which could be used for triggering calculations manually - we might
+also take the real fd, on the other hand, which would only lead to the
+IOManager sending out two notifications, which is not too critical
+================================================================================
+problem:
+
+iomanager reentrancy - the engine probably needs to be partially reentrant,
+if we are to expect that a synchronous destruction of a module (such as in
+a remote unref) transactionsynchronizes itself with the engine - but if we
+expect this, then we will need to register some fds reentrant with the engine
+
+well - we could - for a start - try to NOT reselect all fds to get a snapshot
+of the whole world in one piece - but try to 1:1 map iomanager callbacks to
+revents - this might or might not work
+
+
diff --git a/flow/gsl/gsl-mplan.txt b/flow/gsl/gsl-mplan.txt
new file mode 100644
index 0000000..2a80811
--- /dev/null
+++ b/flow/gsl/gsl-mplan.txt
@@ -0,0 +1,226 @@
+The GSL Engine
+==============
+
+The following gives an outline of the conceptual approach to
+simulate flow-system behavior and carries details of the
+implementation along.
+
+Introductionary remarks:
+------------------------
+The GSL Engine simulates signal flow systems by mapping them
+onto a network of signal processing modules which are connected
+via signal streams.
+The signal streams are value quantized and time discrete, where
+floats are used to store the quantized values and the samples are
+taken at arbitrary but equidistant points in time. Also, the
+sampling periods are assumed to be synchronous for all nodes.
+In the public GSL C API, engine modules are exposed as GslModule
+structures, for the internal engine implementation, each
+GslModule is embedded in an OpNode structure.
+
+Node Model:
+-----------
+* a node has n_istreams input streams
+* a node has n_jstreams joint input streams facilities, that is,
+  an unlimited number of ouput streams can be connected to each
+  "joint" input stream
+* a node has n_ostreams output streams
+* all streams are equally value quantized as IEEE754 floats,
+  usually within the range -1..1
+* all streams are synchronously time discrete
+* the flow-system behavior can be iteratively approximated
+  by calculating a node's output streams from its input streams
+* since all streams are equally time discrete, n output
+  values for all output streams can be calculated from n input
+  values at all input streams of a single network
+* some nodes always react delayed ("deferred" nodes) and can
+  guarantee that they can always produce n output values ahead
+  of receiving the corresponding n input values, with n>=1
+* a node that has no output facilities (n_ostreams==0) is
+  considered a "consumer" and has to be processed // FIXME
+
+Node Methods:
+-------------
+->process()
+  This method specifies through one of its arguments
+  the number of iterations the node has to perform,
+  and therefore the number of values that are supplied
+  in its stream input buffers and which have to be supplied
+  in its stream output buffers.
+->process_deferred()
+  This method specifies the number of input values supplied
+  and the number of output values that should be supplied.
+  The number of input values may be smaller than the number
+  of output values requested, in which case the node may return
+  less output values than requested.
+
+Node Relationships:
+-------------------
+Node B is an "input" of node A if:
+  * one of A's input streams is connected to one of B's output streams,
+  or
+  * node C is an "input" of A and B is an "input" of C
+
+Processing Order:
+-----------------
+If node A has an input node B and A is not a deferred node, B has to
+be processed prior to processing A.
+
+Connection Cycles:
+------------------
+Nodes A and B "form a cycle" if A is an input to B and B is an
+input to A.
+
+Invalid Connections:
+--------------------
+For nodes A and B (not necessarily distinct) which form a cycle,
+the connections that the cycle consists of are only valid if
+the following is true:
+  (C is a deferred node) and
+  (C==A or C==B or (if C is completely disconnected, the nodes
+  A and B do not anymore form the cycle))
+
+
+Implementation Notes
+====================
+* if a node is deferred, all output channels are delayed
+* independent leaf nodes (nodes that have no inputs) can be
+  scheduled separately
+* nodes contained in a cycle have to be scheduled together
+
+Scheduling Algorithm
+--------------------
+To schedule a consumer and its dependency nodes, schedule_query() it:
+
+Query and Schedule Node:
+* tag current node
+* ignore scheduled input nodes
+* schedule_query_node on untagged input nodes, then do one of:
+  * schedule input node (if it has no cycles)
+  * resolve all input nodes cycles and then schedule
+    the input nodes cycle (if not self in cycle)
+  * take over cycle dependencies from input node
+* a tagged node is added to the precondition list (opens new cycle)
+* own leaf level is MAX() of input node leaf-levels + 1
+* untag node
+
+Resolving Cycles:
+* eliminate child from precondition list, once the list
+  is empty the cycle is resolved
+* at least one node being eliminated has to be deferred
+  for the cycle to be valid
+
+Scheduling:
+* nodes need to be processed in the order of leaf-level
+* within leaf-levels, processing is determined by a per-node
+  processing costs hint (cheap, normal, expensive)
+
+Implementation Considerations:
+------------------------------
+For deferred nodes, the number n specifying the amount of output
+values that are produced ahead of input can be considered
+mostly-fixed. that is, it's unlikely to change often and will do
+so only at block boundaries.
+Supporting n to be completely variable or considering it mostly
+fixed has certain implications. Here're the considerations that
+led to supporting a completely variable n for the implementation:
+
+n is block-boundary fixed:
++ for complex cycles (i.e. cycles that contain other cycles,
+  "subcycles"), the subcycles can be scheduled separately
+  if the n of the subcycle is >= block_size
+- if n is the only thing that changed at a block-boundary,
+  rescheduling the flow-graph is required in the cases
+  where n = old_n + x with old_n < block_size or if x < 0
+- deferred nodes can not change their delay in response to
+  values of an input stream
+  
+n is variable for every iteration step:
++ no rescheduling is required if n changes at block-boundary
+- subcycles can not be scheduled separately from their outermost
+  cycle
++ the delay of deferred nodes can correlate to an input stream
+
+
+Threads, communication, main loops
+==================================
+
+Thread types:
+* UserThread; for the scope of the engine (the functions exposed in
+  gslengine.h), only one user thread may execute API functions
+  at a time.
+  i.e. if more than one user thread need to call engine API
+  functions, the user has to take measures to avoid concurrency
+  in calling these functions, e.g. by using a GslMutex which is
+  to be locked around engine API calls.
+* MasterThread; the engine, if configured accordingly,
+  sets up one master thread which
+  - processes transactions from the UserThread
+  - schedules processing order of engine modules
+  - processes single modules when required
+  - processes module cycles when required
+  - passes back processed transactions and flow jobs to the
+    UserThread for garbage collection
+* SlaveThread; the engine can be configured to spawn slave threads which,
+  in addition to the master thread
+  - process single modules when required
+  - process module cycles when required
+
+Communication at thread boundaries:
+* Job transaction queue; the UserThread constructs job transactions and
+  enqueues them for the MasterThread. The UserThread also dequeues already
+  processed transactions, in order for destroy functions of modules and
+  accessors to only be executed within the UserThread.
+  Also, the UserThread can wait (block) until all pending transactions
+  have been processed by the MasterThread (in order to sync state with
+  module network contained in the engine).
+* Flow job collection list; the MasterThread adds processed flow jobs into
+  a collection queue, the UserThread then collects the queued flow jobs
+  and frees them.
+* Module/cycle pool; the MasterThread fills in the module/cycle pool with
+  modules which need to be processed. The MasterThread and the SlaveThreads
+  pop modules/cycles from this pool, process them, and push back processed
+  nodes.
+* load control; // FIXME
+
+Main loop integration:
+in order to process certain engine modules only from within
+the UserThread and to drive the engine even without master
+or slave threads, the engine can be hooked up to a main loop
+mechanism supplied by the UserThread.
+The engine provides API entry points to:
+- export file descriptors and timeout, suitable for main loop backends
+  such as poll(2)
+- check whether dispatching is necessary
+- dispatch outstanding work to be performed by the engine
+FIXME: needs mentioning of pollfd/callback jobs
+
+
+TODO:
+=====
+- virtualization (poke ibuffer into outbuffer) flag (needs memcpy for deferred nodes)
+- flag UserThread nodes
+- sample timed jobs
+- need global timestamp
+- need async-queues that have time-stamped jobs
+- process only so much samples until a time-stamped
+  job needs to be processed
+- self-input cycles need to be resolved in parent as well
+- node-locale async timestamped jobs
+- engine-init: { block(pipe-fd), check } 
+- sample-timed activation can offset node's block-boundary
+- need complete_blocks_only flag in node classes
+- cost rating: cost*n_inputs+cost*n_outputs
+- multi-input(joint) streams: job_disconnect(dmod,distr,smod,sistr); (jstreams)
+
+Jan 07 2002	Tim Janik
+	* cosmetic updates, flow jobs
+Aug 19 2001	Tim Janik
+	* notes on threads, communication, main loops
+Jul 29 2001	Tim Janik
+	* wording/spelling fixups
+May 05 2001	Tim Janik
+	* initial writeup
+
+LocalWords:  GSL API GslModule OpNode istreams ostreams A's B's sync
+LocalWords:  gslengine GslMutex UserThread MasterThread SlaveThread SlaveThreads
diff --git a/flow/gsl/gsl.3 b/flow/gsl/gsl.3
new file mode 100644
index 0000000..2f7bb31
--- /dev/null
+++ b/flow/gsl/gsl.3
@@ -0,0 +1,822 @@
+.TH "GSL-Functions" 3 "17 May 2002" "BEAST-0.4.1" "BEAST-0.4.1" 
+.SH NAME
+GSL-Functions \- GSL Function Reference
+.SH SYNOPSIS
+\fBgsl_thread_wakeup\fP (\fIthread\fP);
+.br
+\fBgsl_thread_abort\fP (\fIthread\fP);
+.br
+\fBgsl_thread_queue_abort\fP (\fIthread\fP);
+.br
+\fBgsl_thread_aborted\fP ();
+.br
+\fBgsl_thread_sleep\fP (\fImax_msec\fP);
+.br
+\fBgsl_thread_awake_after\fP (\fItick_stamp\fP);
+.br
+\fBgsl_thread_awake_before\fP (\fItick_stamp\fP);
+.br
+\fBgsl_tick_stamp\fP ();
+.br
+\fBgsl_data_find_block\fP (\fIhandle\fP, \fIn_values\fP, \fIvalues\fP, \fIepsilon\fP);
+.br
+\fBgsl_module_tick_stamp\fP (\fImodule\fP);
+.br
+\fBgsl_job_integrate\fP (\fImodule\fP);
+.br
+\fBgsl_job_discard\fP (\fImodule\fP);
+.br
+\fBgsl_job_connect\fP (\fIsrc_module\fP, \fIsrc_ostream\fP, \fIdest_module\fP, \fIdest_istream\fP);
+.br
+\fBgsl_job_disconnect\fP (\fIdest_module\fP, \fIdest_istream\fP);
+.br
+\fBGslAccessFunc\fP (\fImodule\fP, \fIdata\fP);
+.br
+\fBgsl_job_access\fP (\fImodule\fP, \fIaccess_func\fP, \fIdata\fP, \fIfree_func\fP);
+.br
+\fBgsl_flow_job_access\fP (\fImodule\fP, \fItick_stamp\fP, \fIaccess_func\fP, \fIdata\fP, \fIfree_func\fP);
+.br
+\fBGslPollFunc\fP (\fIdata\fP, \fIn_values\fP, \fItimeout_p\fP, \fIn_fds\fP, \fIfds\fP, \fIrevents_filled\fP);
+.br
+\fBgsl_job_add_poll\fP (\fIpoll_func\fP, \fIdata\fP, \fIfree_func\fP, \fIn_fds\fP, \fIfds\fP);
+.br
+\fBgsl_job_remove_poll\fP (\fIpoll_func\fP, \fIdata\fP);
+.br
+\fBgsl_job_debug\fP (\fIdebug\fP);
+.br
+\fBgsl_trans_open\fP ();
+.br
+\fBgsl_trans_add\fP (\fItrans\fP, \fIjob\fP);
+.br
+\fBgsl_trans_commit\fP (\fItrans\fP);
+.br
+\fBgsl_trans_dismiss\fP (\fItrans\fP);
+.br
+\fBgsl_transact\fP (\fIjob\fP, \fI...\fP);
+.br
+\fBgsl_engine_init\fP (\fIrun_threaded\fP, \fIblock_size\fP, \fIsample_freq\fP, \fIsub_sample_mask\fP);
+.br
+\fBgsl_engine_wait_on_trans\fP ();
+.br
+\fBgsl_power2_fftac\fP (\fIn_values\fP, \fIri_values_in\fP, \fIri_values_out\fP);
+.br
+\fBgsl_power2_fftsc\fP (\fIn_values\fP, \fIri_values_in\fP, \fIri_values_out\fP);
+.br
+\fBgsl_power2_fftar\fP (\fIn_values\fP, \fIr_values_in\fP, \fIri_values_out\fP);
+.br
+\fBgsl_power2_fftsr\fP (\fIn_values\fP, \fIri_values_in\fP, \fIr_values_out\fP);
+.br
+\fBgsl_filter_tscheb2_steepness_db\fP (\fIiorder\fP, \fIc_freq\fP, \fIepsilon\fP, \fIstopband_db\fP);
+.br
+\fBgsl_filter_tscheb2_steepness\fP (\fIiorder\fP, \fIc_freq\fP, \fIepsilon\fP, \fIresidue\fP);
+.br
+\fBgsl_filter_butter_lp\fP (\fIiorder\fP, \fIfreq\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_tscheb1_lp\fP (\fIiorder\fP, \fIfreq\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_tscheb2_lp\fP (\fIiorder\fP, \fIfreq\fP, \fIsteepness\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_butter_hp\fP (\fIiorder\fP, \fIfreq\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_tscheb1_hp\fP (\fIiorder\fP, \fIfreq\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_tscheb2_hp\fP (\fIiorder\fP, \fIfreq\fP, \fIsteepness\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_butter_bp\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_tscheb1_bp\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_tscheb2_bp\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIsteepness\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_butter_bs\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_tscheb1_bs\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_tscheb2_bs\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIsteepness\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.br
+\fBgsl_filter_fir_approx\fP (\fIiorder\fP, \fIfreq\fP, \fIvalue\fP);
+.br
+\fBgsl_filter_sine_scan\fP (\fIorder\fP, \fIa\fP, \fIb\fP, \fIfreq\fP, \fIn_values\fP);
+.br
+\fBgsl_engine_garbage_collect\fP ();
+.br
+\fBgsl_signal_exp2\fP ();
+.br
+\fBgsl_approx_exp2\fP (\fIex\fP);
+.br
+\fBgsl_approx_atan1\fP (\fIx\fP);
+.br
+\fBgsl_approx_atan1_prescale\fP (\fIboost_amount\fP);
+.br
+\fBgsl_approx_qcircle1\fP (\fIx\fP);
+.br
+\fBgsl_approx_qcircle2\fP (\fIx\fP);
+.br
+\fBgsl_approx_qcircle3\fP (\fIx\fP);
+.br
+\fBgsl_approx_qcircle4\fP (\fIx\fP);
+.br
+.SH DESCRIPTION
+.SS \fBgsl_thread_wakeup\fP (\fIthread\fP);
+.PD 0
+.IP \fIGslThread*\ thread\fP 19
+thread to wake up
+.PD 1
+.PP
+Wake up a currently sleeping thread. In practice, this function simply causes the next call to \fBgsl_thread_sleep()\fP within \fIthread\fP to last for 0 seconds.  
+.PD
+.SS \fBgsl_thread_abort\fP (\fIthread\fP);
+.PD 0
+.IP \fIGslThread*\ thread\fP 19
+thread to abort
+.PD 1
+.PP
+Abort a currently running thread. This function does not return until the thread in question terminated execution. Note that the thread handle gets invalidated with invocation of \fBgsl_thread_abort()\fP or \fBgsl_thread_queue_abort()\fP.  
+.PD
+.SS \fBgsl_thread_queue_abort\fP (\fIthread\fP);
+.PD 0
+.IP \fIGslThread*\ thread\fP 19
+thread to abort
+.PD 1
+.PP
+Same as \fBgsl_thread_abort()\fP, but returns as soon as possible, even if thread hasn't stopped execution yet. Note that the thread handle gets invalidated with invocation of \fBgsl_thread_abort()\fP or \fBgsl_thread_queue_abort()\fP.  
+.PD
+.SS \fBgsl_thread_aborted\fP ();
+.PD 0
+.IP \fIRETURNS:\fP 11
+\fITRUE\fP if the thread should abort execution
+.PD 1
+.PP
+Find out if the currently running thread should be aborted (the thread is supposed to return from its main thread function).  
+.PD
+.SS \fBgsl_thread_sleep\fP (\fImax_msec\fP);
+.PD 0
+.IP \fIglong\ \ max_msec\fP 17
+maximum amount of milli seconds to sleep (-1 for infinite time)
+.IP \fIRETURNS:\fP 17
+\fITRUE\fP if the thread should continue execution
+.PD 1
+.PP
+Sleep for the amount of time given. This function may get interrupted by wakeup or abort requests, it returns whether the thread is supposed to continue execution after waking up.  
+.PD
+.SS \fBgsl_thread_awake_after\fP (\fItick_stamp\fP);
+.PD 0
+.IP \fIguint64\ \ tick_stamp\fP 21
+tick stamp update to trigger wakeup
+.PD 1
+.PP
+Wakeup the currently running thread after the global tick stamp (see \fBgsl_tick_stamp()\fP) has been updated to \fItick_stamp\fP. (If the moment of wakeup has already passed by, the thread is woken up at the next global tick stamp update.)  
+.PD
+.SS \fBgsl_thread_awake_before\fP (\fItick_stamp\fP);
+.PD 0
+.IP \fIguint64\ \ tick_stamp\fP 21
+tick stamp update to trigger wakeup
+.PD 1
+.PP
+Wakeup the currently running thread upon the last global tick stamp update (see \fBgsl_tick_stamp()\fP) that happens prior to updating the global tick stamp to \fItick_stamp\fP. (If the moment of wakeup has already passed by, the thread is woken up at the next global tick stamp update.)  
+.PD
+.SS \fBgsl_tick_stamp\fP ();
+.PD 0
+.IP \fIRETURNS:\fP 11
+GSL's execution tick stamp as unsigned 64bit integer
+.PD 1
+.PP
+Retrive the GSL global tick stamp. GSL increments its global tick stamp at certain intervals, by specific amounts (refer to \fBgsl_engine_init()\fP for further details). The tick stamp is a non-wrapping, unsigned 64bit integer greater than 0. Threads can schedule sleep interruptions at certain tick stamps with \fBgsl_thread_awake_after()\fP and \fBgsl_thread_awake_before()\fP. Tick stamp updating occours at GSL engine block processing boundaries, so code that can guarantee to not run across those boundaries (for instance \fBGslProcessFunc()\fP functions) may use the macro \fIGSL_TICK_STAMP\fP to retrive the current tick in a faster manner (not involving mutex locking). See also \fBgsl_module_tick_stamp()\fP.  
+.PD
+.SS \fBgsl_data_find_block\fP (\fIhandle\fP, \fIn_values\fP, \fIvalues\fP, \fIepsilon\fP);
+.PD 0
+.IP \fIGslDataHandle*\ handle\fP 25
+an open GslDataHandle
+.IP \fIguint\ \ \ \ \ \ \ \ \ \ n_values\fP 25
+amount of values to look for
+.IP \fIconst\ gfloat*\ \ values\fP 25
+values to find
+.IP \fIgfloat\ \ \ \ \ \ \ \ \ epsilon\fP 25
+maximum difference upon comparisions
+.IP \fIRETURNS:\fP 25
+position of values in data handle or -1
+.PD 1
+.PP
+Find the position of a block of values within a data handle, where all values compare to the reference values with a delta smaller than epsilon.  
+.PD
+.SS \fBgsl_module_tick_stamp\fP (\fImodule\fP);
+.PD 0
+.IP \fIGslModule*\ module\fP 19
+a GSL engine module
+.IP \fIRETURNS:\fP 19
+the module's tick stamp, indicating its process status
+.PD 1
+.PP
+Any thread may call this function on a valid engine module. The module specific tick stamp is updated to \fBgsl_tick_stamp()\fP + \fIn_values\fP every time its \fBGslProcessFunc()\fP function was called. See also \fBgsl_tick_stamp()\fP.  
+.PD
+.SS \fBgsl_job_integrate\fP (\fImodule\fP);
+.PD 0
+.IP \fIGslModule*\ module\fP 19
+The module to integrate
+.IP \fIRETURNS:\fP 19
+New job suitable for \fBgsl_trans_add()\fP
+.PD 1
+.PP
+Create a new transaction job to integrate \fImodule\fP into the engine.  
+.PD
+.SS \fBgsl_job_discard\fP (\fImodule\fP);
+.PD 0
+.IP \fIGslModule*\ module\fP 19
+The module to discard
+.IP \fIRETURNS:\fP 19
+New job suitable for \fBgsl_trans_add()\fP
+.PD 1
+.PP
+Create a new transaction job which removes \fImodule\fP from the engine and destroys it.  
+.PD
+.SS \fBgsl_job_connect\fP (\fIsrc_module\fP, \fIsrc_ostream\fP, \fIdest_module\fP, \fIdest_istream\fP);
+.PD 0
+.IP \fIGslModule*\ src_module\fP 25
+Module with output stream
+.IP \fIguint\ \ \ \ \ \ src_ostream\fP 25
+Index of output stream of \fIsrc_module\fP
+.IP \fIGslModule*\ dest_module\fP 25
+Module with unconnected input stream
+.IP \fIguint\ \ \ \ \ \ dest_istream\fP 25
+Index of input stream of \fIdest_module\fP
+.IP \fIRETURNS:\fP 25
+New job suitable for \fBgsl_trans_add()\fP
+.PD 1
+.PP
+Create a new transaction job which connects the ouput stream \fIsrc_ostream\fP of module \fIsrc_module\fP to the input stream \fIdest_istream\fP of module \fIdest_module\fP (it is an error if the input stream is already connected by the time the job is executed).  
+.PD
+.SS \fBgsl_job_disconnect\fP (\fIdest_module\fP, \fIdest_istream\fP);
+.PD 0
+.IP \fIGslModule*\ dest_module\fP 25
+Module with connected input stream
+.IP \fIguint\ \ \ \ \ \ dest_istream\fP 25
+Index of input stream of \fIdest_module\fP
+.IP \fIRETURNS:\fP 25
+New job suitable for \fBgsl_trans_add()\fP
+.PD 1
+.PP
+Create a new transaction job which causes the input stream \fIdest_istream\fP of \fIdest_module\fP to be disconnected (it is an error if the input stream isn't connected by the time the job is executed).  
+.PD
+.SS \fBGslAccessFunc\fP (\fImodule\fP, \fIdata\fP);
+.PD 0
+.IP \fI\ module\fP 9
+Module to operate on
+.IP \fI\ data\fP 9
+Accessor data
+.PD 1
+.PP
+The GslAccessFunc is a user supplied callback function which can access a module in times it is not processing. Accessors are usually used to either read out a module's current state, or to modify its state. An accessor may only operate on the \fIdata\fP and the \fImodule\fP passed in to it.  
+.PD
+.SS \fBgsl_job_access\fP (\fImodule\fP, \fIaccess_func\fP, \fIdata\fP, \fIfree_func\fP);
+.PD 0
+.IP \fIGslModule*\ \ \ \ \ module\fP 28
+The module to access
+.IP \fIGslAccessFunc\ \ access_func\fP 28
+The accessor function
+.IP \fIgpointer\ \ \ \ \ \ \ data\fP 28
+Data passed in to the accessor
+.IP \fIGslFreeFunc\ \ \ \ free_func\fP 28
+Function to free \fIdata\fP
+.IP \fIRETURNS:\fP 28
+New job suitable for \fBgsl_trans_add()\fP
+.PD 1
+.PP
+Create a new transaction job which will invoke \fIaccess_func\fP on \fImodule\fP with \fIdata\fP when the transaction queue is processed to modify the module's state.  
+.PD
+.SS \fBgsl_flow_job_access\fP (\fImodule\fP, \fItick_stamp\fP, \fIaccess_func\fP, \fIdata\fP, \fIfree_func\fP);
+.PD 0
+.IP \fIGslModule*\ \ \ \ \ module\fP 28
+
+.IP \fIguint64\ \ \ \ \ \ \ \ tick_stamp\fP 28
+
+.IP \fIGslAccessFunc\ \ access_func\fP 28
+
+.IP \fIgpointer\ \ \ \ \ \ \ data\fP 28
+
+.IP \fIGslFreeFunc\ \ \ \ free_func\fP 28
+
+.PD 1
+.PP
+
+.PD
+.SS \fBGslPollFunc\fP (\fIdata\fP, \fIn_values\fP, \fItimeout_p\fP, \fIn_fds\fP, \fIfds\fP, \fIrevents_filled\fP);
+.PD 0
+.IP \fI\ data\fP 17
+Data of poll function
+.IP \fI\ n_values\fP 17
+Minimum number of values the engine wants to process
+.IP \fI\ timeout_p\fP 17
+Location of timeout value
+.IP \fI\ n_fds\fP 17
+Number of file descriptors used for polling
+.IP \fI\ fds\fP 17
+File descriptors to be used for polling
+.IP \fI\ revents_filled\fP 17
+Indicates whether \fIfds\fP actually have their ->revents field filled with valid data.
+.IP \fIRETURNS:\fP 17
+A boolean value indicating whether the engine should process data right now
+.PD 1
+.PP
+The GslPollFunc is a user supplied callback function which can be hooked into the GSL engine. The engine uses the poll functions to determine whether processing of \fIn_values\fP in its module network is necessary. In order for the poll functions to react to extern events, such as device driver status changes, the engine will \fBpoll(2)\fP the \fIfds\fP of the poll function and invoke the callback with \fIrevents_filled\fP==\fITRUE\fP if any of its \fIfds\fP changed state. The callback may also be invoked at other random times with \fIrevents_filled\fP=\fIFALSE\fP. It is supposed to return \fITRUE\fP if network processing is currently necessary, and \fIFALSE\fP if not. If \fIFALSE\fP is returned, \fItimeout_p\fP may be filled with the number of milliseconds the engine should use for polling at maximum.  
+.PD
+.SS \fBgsl_job_add_poll\fP (\fIpoll_func\fP, \fIdata\fP, \fIfree_func\fP, \fIn_fds\fP, \fIfds\fP);
+.PD 0
+.IP \fIGslPollFunc\ \ \ \ \ \ poll_func\fP 28
+Poll function to add
+.IP \fIgpointer\ \ \ \ \ \ \ \ \ data\fP 28
+Data of poll function
+.IP \fIGslFreeFunc\ \ \ \ \ \ free_func\fP 28
+Function to free \fIdata\fP
+.IP \fIguint\ \ \ \ \ \ \ \ \ \ \ \ n_fds\fP 28
+Number of poll file descriptors
+.IP \fIconst\ GslPollFD*\ fds\fP 28
+File descriptors to \fBselect(2)\fP or \fBpoll(2)\fP on
+.IP \fIRETURNS:\fP 28
+New job suitable for \fBgsl_trans_add()\fP
+.PD 1
+.PP
+Create a new transaction job which adds a poll function to the engine. The poll function is used by the engine to determine whether processing is currently necessary.  
+.PD
+.SS \fBgsl_job_remove_poll\fP (\fIpoll_func\fP, \fIdata\fP);
+.PD 0
+.IP \fIGslPollFunc\ \ poll_func\fP 24
+Poll function to remove
+.IP \fIgpointer\ \ \ \ \ data\fP 24
+Data of poll function
+.IP \fIRETURNS:\fP 24
+New job suitable for \fBgsl_trans_add()\fP
+.PD 1
+.PP
+Create a new transaction job which removes a previously inserted poll function from the engine.  
+.PD
+.SS \fBgsl_job_debug\fP (\fIdebug\fP);
+.PD 0
+.IP \fIconst\ gchar*\ debug\fP 20
+Debug message
+.IP \fIRETURNS:\fP 20
+New job suitable for \fBgsl_trans_add()\fP
+.PD 1
+.PP
+Create a new transaction job which issues \fIdebug\fP message when the job is executed. This function is meant for debugging purposes during development phase only and shouldn't be used in production code.  
+.PD
+.SS \fBgsl_trans_open\fP ();
+.PD 0
+.IP \fIRETURNS:\fP 11
+Newly opened empty transaction
+.PD 1
+.PP
+Open up a new transaction to commit jobs to the GSL engine. This function may cause garbage collection (see \fBgsl_engine_garbage_collect()\fP).  
+.PD
+.SS \fBgsl_trans_add\fP (\fItrans\fP, \fIjob\fP);
+.PD 0
+.IP \fIGslTrans*\ trans\fP 17
+Opened transaction
+.IP \fIGslJob*\ \ \ job\fP 17
+Job to add
+.PD 1
+.PP
+Append a job to an opened transaction.  
+.PD
+.SS \fBgsl_trans_commit\fP (\fItrans\fP);
+.PD 0
+.IP \fIGslTrans*\ trans\fP 17
+Opened transaction
+.PD 1
+.PP
+Close the transaction and commit it to the engine. The engine will execute the jobs contained in this transaction as soon as it has completed its current processing cycle. The jobs will be executed in the exact order they were added to the transaction.  
+.PD
+.SS \fBgsl_trans_dismiss\fP (\fItrans\fP);
+.PD 0
+.IP \fIGslTrans*\ trans\fP 17
+Opened transaction
+.PD 1
+.PP
+Close and discard the transaction, destroy all jobs currently contained in it and do not execute them. This function may cause garbage collection (see \fBgsl_engine_garbage_collect()\fP).  
+.PD
+.SS \fBgsl_transact\fP (\fIjob\fP, \fI...\fP);
+.PD 0
+.IP \fI\ job\fP 6
+First job
+.IP \fI\ ...\fP 6
+\fINULL\fP terminated job list
+.PD 1
+.PP
+Convenience function which openes up a new transaction, collects the \fINULL\fP terminated job list passed to the function, and commits the transaction.  
+.PD
+.SS \fBgsl_engine_init\fP (\fIrun_threaded\fP, \fIblock_size\fP, \fIsample_freq\fP, \fIsub_sample_mask\fP);
+.PD 0
+.IP \fIgboolean\ \ run_threaded\fP 27
+
+.IP \fIguint\ \ \ \ \ block_size\fP 27
+number of values to process block wise
+.IP \fIguint\ \ \ \ \ sample_freq\fP 27
+
+.IP \fIguint\ \ \ \ \ sub_sample_mask\fP 27
+
+.PD 1
+.PP
+Initialize the GSL engine, this function must be called prior to any other engine related function and can only be invoked once. The \fIblock_size\fP determines the amount by which the global tick stamp (see \fBgsl_tick_stamp()\fP) is updated everytime the whole module network completed processing \fIblock_size\fP values.  
+.PD
+.SS \fBgsl_engine_wait_on_trans\fP ();
+.PD 0
+.PD 1
+.PP
+Wait until all pending transactions have been processed by the GSL Engine. This function may cause garbage collection (see \fBgsl_engine_garbage_collect()\fP).  
+.PD
+.SS \fBgsl_power2_fftac\fP (\fIn_values\fP, \fIri_values_in\fP, \fIri_values_out\fP);
+.PD 0
+.IP \fI\ n_values\fP 16
+Number of complex values
+.IP \fI\ ri_values_in\fP 16
+Complex sample values [0..n_values*2-1]
+.IP \fI\ ri_values_out\fP 16
+Complex frequency values [0..n_values*2-1]
+.PD 1
+.PP
+This function performs a decimation in time fourier transformation in forward direction, where the input values are equidistant sampled data, and the output values contain the frequency proportions of the input. The input and output arrays are complex values with real and imaginery portions interleaved, adressable in the range [0..2*n_values-1], where n_values must be a power of two. Frequencies are stored in-order, the K-th output corresponds to the frequency K/n_values. (If you want to interpret negative frequencies, note that the frequencies -K/n_values and (n_values-K)/n_values are equivalent). Note that the transformation is performed out of place, the input array is not modified, and may not overlap with the output array.  
+.PD
+.SS \fBgsl_power2_fftsc\fP (\fIn_values\fP, \fIri_values_in\fP, \fIri_values_out\fP);
+.PD 0
+.IP \fI\ n_values\fP 16
+Number of complex values
+.IP \fI\ ri_values_in\fP 16
+Complex frequency values [0..n_values*2-1]
+.IP \fI\ ri_values_out\fP 16
+Complex sample values [0..n_values*2-1]
+.PD 1
+.PP
+This function performs a decimation in time fourier transformation in backwards direction with normalization. As such, this function represents the counterpart to \fBgsl_power2_fftac()\fP, that is, a value array which is transformed into the frequency domain with \fBgsl_power2_fftac()\fP can be reconstructed by issuing \fBgsl_power2_fftsc()\fP on the transform. Note that the transformation is performed out of place, the input array is not modified, and may not overlap with the output array.  
+.PD
+.SS \fBgsl_power2_fftar\fP (\fIn_values\fP, \fIr_values_in\fP, \fIri_values_out\fP);
+.PD 0
+.IP \fI\ n_values\fP 16
+Number of complex values
+.IP \fI\ r_values_in\fP 16
+Real sample values [0..n_values-1]
+.IP \fI\ ri_values_out\fP 16
+Complex frequency values [0..n_values-1]
+.PD 1
+.PP
+Real valued variant of \fBgsl_power2_fftac()\fP, the input array contains real valued equidistant sampled data [0..n_values-1], and the output array contains the positive frequency half of the complex valued fourier transform. Note, that the complex valued fourier transform H of a purely real valued set of data, satisfies \fBH(-f)\fP = Conj(\fBH(f)\fP), where \fBConj()\fP denotes the complex conjugate, so that just the positive frequency half suffices to describe the entire frequency spectrum. Even so, the resulting n_values/2 complex frequencies are one value off in storage size, but the resulting frequencies \fBH(0)\fP and \fBH(n_values/2)\fP are both real valued, so the real portion of \fBH(n_values/2)\fP is stored in ri_values_out[1] (the imaginery part of \fBH(0)\fP), so that both r_values_in and ri_values_out can be of size n_values. Note that the transformation is performed out of place, the input array is not modified, and may not overlap with the output array.  
+.PD
+.SS \fBgsl_power2_fftsr\fP (\fIn_values\fP, \fIri_values_in\fP, \fIr_values_out\fP);
+.PD 0
+.IP \fI\ n_values\fP 15
+Number of complex values
+.IP \fI\ ri_values_in\fP 15
+Complex frequency values [0..n_values-1]
+.IP \fI\ r_values_out\fP 15
+Real sample values [0..n_values-1]
+.PD 1
+.PP
+Real valued variant of \fBgsl_power2_fftsc()\fP, counterpart to \fBgsl_power2_fftar()\fP, using the same frequency storage format. A real valued data set transformed into the frequency domain with \fBgsl_power2_fftar()\fP can be reconstructed using this function. Note that the transformation is performed out of place, the input array is not modified, and may not overlap with the output array.  
+.PD
+.SS \fBgsl_filter_tscheb2_steepness_db\fP (\fIiorder\fP, \fIc_freq\fP, \fIepsilon\fP, \fIstopband_db\fP);
+.PD 0
+.IP \fIunsigned\ int\ \ iorder\fP 27
+filter order
+.IP \fIdouble\ \ \ \ \ \ \ \ c_freq\fP 27
+passband cutoff frequency (0..pi)
+.IP \fIdouble\ \ \ \ \ \ \ \ epsilon\fP 27
+fall off at passband frequency (0..1)
+.IP \fIdouble\ \ \ \ \ \ \ \ stopband_db\fP 27
+reduction in stopband in dB (>= 0)
+.PD 1
+.PP
+Calculates the steepness parameter for Tschebyscheff type 2 lowpass filter, based on the ripple residue in the stop band.  
+.PD
+.SS \fBgsl_filter_tscheb2_steepness\fP (\fIiorder\fP, \fIc_freq\fP, \fIepsilon\fP, \fIresidue\fP);
+.PD 0
+.IP \fIunsigned\ int\ \ iorder\fP 23
+filter order
+.IP \fIdouble\ \ \ \ \ \ \ \ c_freq\fP 23
+passband cutoff frequency (0..pi)
+.IP \fIdouble\ \ \ \ \ \ \ \ epsilon\fP 23
+fall off at passband frequency (0..1)
+.IP \fIdouble\ \ \ \ \ \ \ \ residue\fP 23
+maximum of transfer function in stopband (0..1)
+.PD 1
+.PP
+Calculates the steepness parameter for Tschebyscheff type 2 lowpass filter, based on ripple residue in the stop band.  
+.PD
+.SS \fBgsl_filter_butter_lp\fP (\fIiorder\fP, \fIfreq\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 10
+filter order
+.IP \fI\ freq\fP 10
+cutoff frequency (0..pi)
+.IP \fI\ epsilon\fP 10
+fall off at cutoff frequency (0..1)
+.IP \fI\ a\fP 10
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 10
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Butterworth lowpass filter.  
+.PD
+.SS \fBgsl_filter_tscheb1_lp\fP (\fIiorder\fP, \fIfreq\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 10
+filter order
+.IP \fI\ freq\fP 10
+cutoff frequency (0..pi)
+.IP \fI\ epsilon\fP 10
+fall off at cutoff frequency (0..1)
+.IP \fI\ a\fP 10
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 10
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Tschebyscheff type 1 lowpass filter.  
+.PD
+.SS \fBgsl_filter_tscheb2_lp\fP (\fIiorder\fP, \fIfreq\fP, \fIsteepness\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 12
+filter order
+.IP \fI\ freq\fP 12
+passband cutoff frequency (0..pi)
+.IP \fI\ steepness\fP 12
+frequency steepness (c_freq * steepness < pi)
+.IP \fI\ epsilon\fP 12
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 12
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 12
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Tschebyscheff type 2 lowpass filter. To gain a transition band between freq1 and freq2, pass arguements \fIfreq\fP=freq1 and \fIsteepness\fP=freq2/freq1. To specify the transition band width in fractions of octaves, pass \fIsteepness\fP=2^octave_fraction.  
+.PD
+.SS \fBgsl_filter_butter_hp\fP (\fIiorder\fP, \fIfreq\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 10
+filter order
+.IP \fI\ freq\fP 10
+passband frequency (0..pi)
+.IP \fI\ epsilon\fP 10
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 10
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 10
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Butterworth highpass filter.  
+.PD
+.SS \fBgsl_filter_tscheb1_hp\fP (\fIiorder\fP, \fIfreq\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 10
+filter order
+.IP \fI\ freq\fP 10
+passband frequency (0..pi)
+.IP \fI\ epsilon\fP 10
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 10
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 10
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Tschebyscheff type 1 highpass filter.  
+.PD
+.SS \fBgsl_filter_tscheb2_hp\fP (\fIiorder\fP, \fIfreq\fP, \fIsteepness\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 12
+filter order
+.IP \fI\ freq\fP 12
+stopband frequency (0..pi)
+.IP \fI\ steepness\fP 12
+frequency steepness
+.IP \fI\ epsilon\fP 12
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 12
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 12
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Tschebyscheff type 2 highpass filter.  
+.PD
+.SS \fBgsl_filter_butter_bp\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 10
+filter order (must be even)
+.IP \fI\ freq1\fP 10
+stopband end frequency (0..pi)
+.IP \fI\ freq2\fP 10
+passband end frequency (0..pi)
+.IP \fI\ epsilon\fP 10
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 10
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 10
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Butterworth bandpass filter.  
+.PD
+.SS \fBgsl_filter_tscheb1_bp\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 10
+filter order (must be even)
+.IP \fI\ freq1\fP 10
+stopband end frequency (0..pi)
+.IP \fI\ freq2\fP 10
+passband end frequency (0..pi)
+.IP \fI\ epsilon\fP 10
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 10
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 10
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Tschebyscheff type 1 bandpass filter.  
+.PD
+.SS \fBgsl_filter_tscheb2_bp\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIsteepness\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 12
+filter order (must be even)
+.IP \fI\ freq1\fP 12
+stopband end frequency (0..pi)
+.IP \fI\ freq2\fP 12
+passband end frequency (0..pi)
+.IP \fI\ steepness\fP 12
+frequency steepness factor
+.IP \fI\ epsilon\fP 12
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 12
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 12
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Tschebyscheff type 2 bandpass filter.  
+.PD
+.SS \fBgsl_filter_butter_bs\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 10
+filter order (must be even)
+.IP \fI\ freq1\fP 10
+passband end frequency (0..pi)
+.IP \fI\ freq2\fP 10
+stopband end frequency (0..pi)
+.IP \fI\ epsilon\fP 10
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 10
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 10
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Butterworth bandstop filter.  
+.PD
+.SS \fBgsl_filter_tscheb1_bs\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 10
+filter order (must be even)
+.IP \fI\ freq1\fP 10
+passband end frequency (0..pi)
+.IP \fI\ freq2\fP 10
+stopband end frequency (0..pi)
+.IP \fI\ epsilon\fP 10
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 10
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 10
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Tschebyscheff type 1 bandstop filter.  
+.PD
+.SS \fBgsl_filter_tscheb2_bs\fP (\fIiorder\fP, \fIfreq1\fP, \fIfreq2\fP, \fIsteepness\fP, \fIepsilon\fP, \fIa\fP, \fIb\fP);
+.PD 0
+.IP \fI\ iorder\fP 12
+filter order (must be even)
+.IP \fI\ freq1\fP 12
+passband end frequency (0..pi)
+.IP \fI\ freq2\fP 12
+stopband end frequency (0..pi)
+.IP \fI\ steepness\fP 12
+frequency steepness factor
+.IP \fI\ epsilon\fP 12
+fall off at passband frequency (0..1)
+.IP \fI\ a\fP 12
+root polynomial coefficients a[0..iorder]
+.IP \fI\ b\fP 12
+pole polynomial coefficients b[0..iorder]
+.PD 1
+.PP
+Tschebyscheff type 2 bandstop filter.  
+.PD
+.SS \fBgsl_filter_fir_approx\fP (\fIiorder\fP, \fIfreq\fP, \fIvalue\fP);
+.PD 0
+.IP \fI\ iorder\fP 9
+order of the filter (must be oven, >= 2)
+.IP \fI\ freq\fP 9
+the frequencies of the transfer function
+.IP \fI\ value\fP 9
+the desired value of the transfer function
+.PD 1
+.PP
+Approximates a given transfer function with an iorder-coefficient FIR filter. It is recommended to provide enough frequency values, so that \fIn_points\fP >= \fIiorder\fP.  
+.PD
+.SS \fBgsl_filter_sine_scan\fP (\fIorder\fP, \fIa\fP, \fIb\fP, \fIfreq\fP, \fIn_values\fP);
+.PD 0
+.IP \fIguint\ \ \ \ \ \ \ \ \ \ order\fP 25
+order of the iir filter
+.IP \fIconst\ gdouble*\ a\fP 25
+root polynomial coefficients of the filter a[0..order]
+.IP \fIconst\ gdouble*\ b\fP 25
+pole polynomial coefficients of the filter b[0..order]
+.IP \fIgdouble\ \ \ \ \ \ \ \ freq\fP 25
+frequency to test
+.IP \fIguint\ \ \ \ \ \ \ \ \ \ n_values\fP 25
+number of samples
+.PD 1
+.PP
+This function sends a sine signal of the desired frequency through an IIR filter, to test the value of the transfer function at a given point. It uses gsl_iir_filter_eval to do so.  Compared to a "mathematical approach" of finding the transfer function, this function makes it possible to see the effects of finite arithmetic during filter evaluation.  The first half of the output signal is not considered, since a lot of IIR filters have a transient phase where also overshoot is possible.  For n_values, you should specify a reasonable large value. It should be a lot larger than the filter order, and large enough to let the input signal become (close to) 1.0 multiple times.  
+.PD
+.SS \fBgsl_engine_garbage_collect\fP ();
+.PD 0
+.PD 1
+.PP
+GSL Engine user thread function. Collects processed jobs and transactions from the engine and frees them, this involves callback invocation of \fBGslFreeFunc()\fP functions, e.g. from \fBgsl_job_access()\fP or \fBgsl_flow_job_access()\fP jobs. This function may only be called from the user thread, as \fBGslFreeFunc()\fP functions are guranteed to be executed in the user thread.  
+.PD
+.SS \fBgsl_signal_exp2\fP ();
+.PD 0
+.PD 1
+.PP
+Deprecated in favour of \fBgsl_approx_exp2()\fP.  
+.PD
+.SS \fBgsl_approx_exp2\fP (\fIex\fP);
+.PD 0
+.IP \fIfloat\ \ ex\fP 11
+exponent within [-127..127]
+.IP \fIRETURNS:\fP 11
+y approximating 2^x
+.PD 1
+.PP
+Fast approximation of 2 raised to the power of x. Multiplicative error stays below 8e-6 and aproaches zero for integer values of x (i.e. x - floor (x) = 0).  
+.PD
+.SS \fBgsl_approx_atan1\fP (\fIx\fP);
+.PD 0
+.IP \fIregister\ double\ \ x\fP 20
+
+.PD 1
+.PP
+Fast \fBatan(x)\fP/(PI/2) approximation, with maximum error < 0.01 and \fBgsl_approx_atan1(0)\fP==0, according to the formula: n1 = -0.41156875521951602506487246309908; n2 = -1.0091272542790025586079663559158; d1 = 0.81901156857081841441890603235599; d2 = 1.0091272542790025586079663559158; \fBpositive_atan1(x)\fP = 1 + (n1 * x + n2) / ((1 + d1 * x) * x + d2);  
+.PD
+.SS \fBgsl_approx_atan1_prescale\fP (\fIboost_amount\fP);
+.PD 0
+.IP \fI\ boost_amount\fP 15
+boost amount between [0..1]
+.IP \fIRETURNS:\fP 15
+prescale factor for \fBgsl_approx_atan1()\fP
+.PD 1
+.PP
+Calculate the prescale factor for \fBgsl_approx_atan1(x*prescale)\fP from a linear boost factor, where 0.5 amounts to prescale=1.0, 1.0 results in maximum boost and 0.0 results in maximum attenuation.  
+.PD
+.SS \fBgsl_approx_qcircle1\fP (\fIx\fP);
+.PD 0
+.IP \fIregister\ double\ \ x\fP 20
+x within [0..1]
+.IP \fIRETURNS:\fP 20
+y for circle approximation within [0..1]
+.PD 1
+.PP
+Fast approximation of the upper right quadrant of a circle. Errors at x=0 and x=1 are zero, for the rest of the curve, the error wasn't minimized, but distributed to best fit the curverture of a quarter circle. The maximum error is below 0.092.  
+.PD
+.SS \fBgsl_approx_qcircle2\fP (\fIx\fP);
+.PD 0
+.IP \fIregister\ double\ \ x\fP 20
+x within [0..1]
+.IP \fIRETURNS:\fP 20
+y for circle approximation within [0..1]
+.PD 1
+.PP
+Fast approximation of the upper left quadrant of a circle. Errors at x=0 and x=1 are zero, for the rest of the curve, the error wasn't minimized, but distributed to best fit the curverture of a quarter circle. The maximum error is below 0.092.  
+.PD
+.SS \fBgsl_approx_qcircle3\fP (\fIx\fP);
+.PD 0
+.IP \fIregister\ double\ \ x\fP 20
+x within [0..1]
+.IP \fIRETURNS:\fP 20
+y for circle approximation within [0..1]
+.PD 1
+.PP
+Fast approximation of the lower left quadrant of a circle. Errors at x=0 and x=1 are zero, for the rest of the curve, the error wasn't minimized, but distributed to best fit the curverture of a quarter circle. The maximum error is below 0.092.  
+.PD
+.SS \fBgsl_approx_qcircle4\fP (\fIx\fP);
+.PD 0
+.IP \fIregister\ double\ \ x\fP 20
+x within [0..1]
+.IP \fIRETURNS:\fP 20
+y for circle approximation within [0..1]
+.PD 1
+.PP
+Fast approximation of the lower right quadrant of a circle. Errors at x=0 and x=1 are zero, for the rest of the curve, the error wasn't minimized, but distributed to best fit the curverture of a quarter circle. The maximum error is below 0.092.  
+.PD
+
diff --git a/flow/gsl/gsl.gnuplot b/flow/gsl/gsl.gnuplot
new file mode 100644
index 0000000..e50c2ae
--- /dev/null
+++ b/flow/gsl/gsl.gnuplot
@@ -0,0 +1,5 @@
+dB(x)=20*log(abs(x))/log(10)	# logarithmische Filterdarstellung in dB (s/20/10/ for abs(x)^2)
+s2z(s)=(1+s)/(1-s)		# s-Ebene -> z-Ebene (bilinear Trans.)
+j={0,1}				# sqrt(-1)
+Z(x)=exp({0,-1}*x)		# gnuplot laufvariable x fuer H(z)
+set samples 4000		# more accuracy
diff --git a/flow/gsl/gslarrows b/flow/gsl/gslarrows
new file mode 100644
index 0000000..04ba5e4
--- /dev/null
+++ b/flow/gsl/gslarrows
@@ -0,0 +1,30 @@
+
+
+# $0+0 == number of arrows
+# $1+0 = first arrow
+# $2+0 = second arrow
+# e.g.
+# gnuplot> call "arrows" 3  "2*3" "0.5*pi" "sqrt(7)"
+
+#debug-args # 0:$0 1:$1 2:$2 3:$3 4:$4 5:$5 6:$6 7:$7 8:$8 9:$9
+
+
+arrow_line_type=0
+set arrow 1 from first $1+0,graph 0 to first $1+0,graph 1 nohead lt arrow_line_type
+set arrow 2 from first $2+0,graph 0 to first $2+0,graph 1 nohead lt arrow_line_type
+set arrow 3 from first $3+0,graph 0 to first $3+0,graph 1 nohead lt arrow_line_type
+set arrow 4 from first $4+0,graph 0 to first $4+0,graph 1 nohead lt arrow_line_type
+set arrow 5 from first $5+0,graph 0 to first $5+0,graph 1 nohead lt arrow_line_type
+set arrow 6 from first $6+0,graph 0 to first $6+0,graph 1 nohead lt arrow_line_type
+set arrow 7 from first $7+0,graph 0 to first $7+0,graph 1 nohead lt arrow_line_type
+set arrow 8 from first $8+0,graph 0 to first $8+0,graph 1 nohead lt arrow_line_type
+set arrow 9 from first $9+0,graph 0 to first $9+0,graph 1 nohead lt arrow_line_type
+if ($0+0 < 9)  set noarrow 9
+if ($0+0 < 8)  set noarrow 8
+if ($0+0 < 7)  set noarrow 7
+if ($0+0 < 6)  set noarrow 6
+if ($0+0 < 5)  set noarrow 5
+if ($0+0 < 4)  set noarrow 4
+if ($0+0 < 3)  set noarrow 3
+if ($0+0 < 2)  set noarrow 2
+if ($0+0 < 1)  set noarrow 1
diff --git a/flow/gsl/gslartsthreads.cc b/flow/gsl/gslartsthreads.cc
new file mode 100644
index 0000000..98094b7
--- /dev/null
+++ b/flow/gsl/gslartsthreads.cc
@@ -0,0 +1,205 @@
+    /*
+
+    Copyright (C) 2001-2002 Stefan Westerfeld
+                            stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "thread.h"
+#include "debug.h"
+#include "gslglib.h"
+#include <pthread.h>
+
+#if defined(__DECCXX)
+#define EXTC extern "C"
+#else
+#define EXTC
+#endif
+
+EXTC gpointer
+gsl_arts_mutex_new ()
+{
+  return new Arts::Mutex;
+}
+
+EXTC void
+gsl_arts_mutex_free (gpointer mutex)
+{
+  Arts::Mutex *m = static_cast<Arts::Mutex *>(mutex);
+  delete m;
+}
+
+EXTC void
+gsl_arts_mutex_lock (gpointer mutex)
+{
+  Arts::Mutex *m = static_cast<Arts::Mutex *>(mutex);
+  m->lock();
+}
+
+EXTC gboolean
+gsl_arts_mutex_trylock (gpointer mutex)
+{
+  Arts::Mutex *m = static_cast<Arts::Mutex *>(mutex);
+  return m->tryLock();
+}
+
+EXTC void
+gsl_arts_mutex_unlock (gpointer mutex)
+{
+  Arts::Mutex *m = static_cast<Arts::Mutex *>(mutex);
+  m->unlock();
+}
+
+EXTC gpointer
+gsl_arts_cond_new ()
+{
+  return new Arts::ThreadCondition;
+}
+
+EXTC void
+gsl_arts_cond_free (gpointer cond)
+{
+  Arts::ThreadCondition *c = static_cast<Arts::ThreadCondition *>(cond);
+  delete c;
+}
+
+EXTC void
+gsl_arts_cond_signal (gpointer cond)
+{
+  Arts::ThreadCondition *c = static_cast<Arts::ThreadCondition *>(cond);
+  c->wakeOne();
+}
+
+EXTC void
+gsl_arts_cond_broadcast (gpointer cond)
+{
+  Arts::ThreadCondition *c = static_cast<Arts::ThreadCondition *>(cond);
+  c->wakeAll();
+}
+
+EXTC void
+gsl_arts_cond_wait (gpointer cond, gpointer mutex)
+{
+  Arts::ThreadCondition *c = static_cast<Arts::ThreadCondition *>(cond);
+  Arts::Mutex *m = static_cast<Arts::Mutex *>(mutex);
+
+  c->wait(*m);
+}
+
+EXTC void
+gsl_arts_cond_timed_wait (gpointer /*cond*/, gpointer /*mutex*/, GTimeVal * /*time*/)
+{
+  arts_assert(false);
+}
+
+
+class GslArtsThread : public Arts::Thread {
+protected:
+  gpointer (*func)(gpointer data);
+  gpointer data;
+  gpointer result;
+
+public:
+  GThread gthread;
+
+  GslArtsThread(gpointer (*func)(gpointer data), gpointer data)
+    : func(func), data(data)
+  {
+    gthread.data = 0;
+  }
+  void run()
+  {
+    result = func(data);
+  }
+};
+
+
+/* KCC (KAI C++) is buggy.  If we write out the type of the first argument
+   to gsl_arts_thread_create(), ala
+     gsl_arts_thread_create (gpointer (*func) (gpointer data2), ...)
+   it becomes C++ linkage, i.e. it's name gets mangled, _despite_ declared
+   extern "C" in the header.  Other sources only calling this function,
+   i.e. those only seeing the prototype correctly call the unmangled
+   extern "C" variant, but for the above reason it isn't defined anywhere.
+   The solution is to go through a typedef for that argument, _which must
+   also be declared extern "C"_.  I'm not sure, but I think it's an error
+   of KCC, that it puts the invisible type of the first arg into C++ mode,
+   although the whole function should be C only.  If one declares
+   two equal function types, one extern "C", one not, they are even assignment
+   compatible.  But somehow KCC puts that type into C++ mode, which for
+   other strange reasons force the whole function to go into C++ linkage.
+   It's enough, when this typedef is local to this file.  (matz)  */
+   
+/* Due to gcc's unhappyness with 'extern "C" typedef ...' we enclose
+   it in a real extern "C" {} block.  */
+extern "C" {
+typedef gpointer (*t_func)(gpointer data2);
+}
+
+// This is C++:
+GThread* gsl_arts_thread_create_full_CPP(gpointer (*func)(gpointer data),
+                                  gpointer               data,
+                                  gulong                 /*stack_size*/,
+                                  gboolean               /*joinable*/,
+                                  gboolean               /*bound*/,
+                                  GThreadPriority        /*priority*/,
+                                  GError               ** /*error*/) 
+{
+  GslArtsThread *thread = new GslArtsThread(func, data);
+  return &thread->gthread;
+}
+
+// This is C:
+extern "C" GThread* 
+gsl_arts_thread_create_full(gpointer (*func)(gpointer data),
+                                  gpointer               data,
+                                  gulong                 stack_size,
+                                  gboolean               joinable,
+                                  gboolean               bound,
+                                  GThreadPriority        priority,
+                                  GError               **error)
+{
+  return gsl_arts_thread_create_full_CPP(func, 
+                                         data, 
+					 stack_size, 
+					 joinable, 
+					 bound,
+					 priority,
+					 error);
+}
+
+EXTC gpointer
+gsl_arts_thread_self ()
+{
+  GslArtsThread *current = static_cast<GslArtsThread *>(Arts::SystemThreads::the()->getCurrentThread());
+ 
+  if(current)
+    return &current->gthread;
+  else
+    {
+      static GThread mainThread = { 0, };
+      return &mainThread;
+    }
+}
+
+EXTC void 
+gsl_arts_thread_init (gpointer /*arg*/)
+{
+}
+
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gslartsthreads.h b/flow/gsl/gslartsthreads.h
new file mode 100644
index 0000000..c9ebf19
--- /dev/null
+++ b/flow/gsl/gslartsthreads.h
@@ -0,0 +1,102 @@
+    /*
+
+    Copyright (C) 2001-2002 Stefan Westerfeld
+                            stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef GSLARTSTHREADS_H
+#define GSLARTSTHREADS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* --- typedefs & structures --- */
+
+typedef struct _GError {
+  const char *message;
+} GError;
+
+typedef struct _GThread {
+  void *data;
+} GThread;
+
+typedef enum
+{
+  G_THREAD_PRIORITY_LOW,
+  G_THREAD_PRIORITY_NORMAL,
+  G_THREAD_PRIORITY_HIGH,
+  G_THREAD_PRIORITY_URGENT
+} GThreadPriority;
+
+#define g_mutex_lock		gsl_arts_mutex_lock
+#define g_mutex_trylock		gsl_arts_mutex_trylock
+#define g_mutex_unlock		gsl_arts_mutex_unlock
+#define g_mutex_new		gsl_arts_mutex_new
+#define g_mutex_free		gsl_arts_mutex_free
+
+#define g_cond_new		gsl_arts_cond_new
+#define g_cond_free		gsl_arts_cond_free
+#define g_cond_signal		gsl_arts_cond_signal
+#define g_cond_broadcast	gsl_arts_cond_broadcast
+#define g_cond_wait		gsl_arts_cond_wait
+#define g_cond_timed_wait	gsl_arts_cond_timed_wait
+
+#define g_thread_create_full	gsl_arts_thread_create_full
+#define g_thread_self		gsl_arts_thread_self
+
+#define	g_thread_init		gsl_arts_thread_init
+
+#define g_error_free(x)         g_assert_not_reached()
+
+/* --- prototypes --- */
+
+gpointer  gsl_arts_mutex_new ();
+void	  gsl_arts_mutex_free (gpointer mutex);
+void	  gsl_arts_mutex_lock (gpointer mutex);
+gboolean  gsl_arts_mutex_trylock (gpointer mutex);
+void	  gsl_arts_mutex_unlock (gpointer mutex);
+
+gpointer  gsl_arts_cond_new ();
+void	  gsl_arts_cond_free (gpointer cond);
+void	  gsl_arts_cond_signal (gpointer cond);
+void	  gsl_arts_cond_broadcast (gpointer cond);
+void	  gsl_arts_cond_wait (gpointer cond, gpointer mutex);
+void	  gsl_arts_cond_timed_wait (gpointer cond, gpointer mutex, GTimeVal *abstime);
+
+GThread* gsl_arts_thread_create_full(gpointer (*func)(gpointer data),
+                                  gpointer               data,
+                                  gulong                 stack_size,
+                                  gboolean               joinable,
+                                  gboolean               bound,
+                                  GThreadPriority        priority,
+                                  GError               **error);
+
+gpointer  gsl_arts_thread_self ();
+
+void      gsl_arts_thread_init (gpointer arg);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/* vim:set ts=8 sts=2 sw=2: */
+
+#endif // GSLARTSTHREADS_H
+
diff --git a/flow/gsl/gslcommon.c b/flow/gsl/gslcommon.c
new file mode 100644
index 0000000..cb16b05
--- /dev/null
+++ b/flow/gsl/gslcommon.c
@@ -0,0 +1,1651 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+#include <string.h>
+#include <sched.h>
+#include <errno.h>
+#include <sys/poll.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+
+#include "gslcommon.h"
+#include "gsldatacache.h"
+
+/* some systems don't have ERESTART (which is what linux returns for system
+ * calls on pipes which are being interrupted). most propably just use EINTR,
+ * and maybe some can return both. so we check for both in the below code,
+ * and alias ERESTART to EINTR if it's not present. compilers are supposed
+ * to catch and optimize the doubled check arising from this.
+ */
+#ifndef ERESTART
+#define ERESTART        EINTR
+#endif
+
+
+#define	PREALLOC		(8)
+#define	SIMPLE_CACHE_SIZE	(64)
+#define	TS8_SIZE		(MAX (sizeof (GTrashStack), 8))
+#define	DBG8_SIZE		(MAX (sizeof (gsize), 8))
+
+
+/* --- variables --- */
+volatile guint64     gsl_externvar_tick_stamp = 0;
+static guint64	     tick_stamp_system_time = 0;
+static guint         global_tick_stamp_leaps = 0;
+static GslDebugFlags gsl_debug_flags = 0;
+
+
+/* --- memory allocation --- */
+static GslMutex     global_memory = { 0, };
+static GTrashStack *simple_cache[SIMPLE_CACHE_SIZE] = { 0, 0, 0, /* ... */ };
+static gulong       memory_allocated = 0;
+
+const guint
+gsl_alloc_upper_power2 (const gulong number)
+{
+  return number ? 1 << g_bit_storage (number - 1) : 0;
+}
+
+static inline gpointer
+low_alloc (gsize mem_size)
+{
+  gpointer mem;
+
+  if (mem_size >= TS8_SIZE && mem_size / 8 < SIMPLE_CACHE_SIZE)
+    {
+      guint cell;
+
+      mem_size = (mem_size + 7) & ~0x7;
+      cell = (mem_size >> 3) - 1;
+      GSL_SPIN_LOCK (&global_memory);
+      mem = g_trash_stack_pop (simple_cache + cell);
+      GSL_SPIN_UNLOCK (&global_memory);
+      if (!mem)
+	{
+	  guint8 *cache_mem = g_malloc (mem_size * PREALLOC);
+	  guint i;
+	  
+	  GSL_SPIN_LOCK (&global_memory);
+	  memory_allocated += mem_size * PREALLOC;
+	  for (i = 0; i < PREALLOC - 1; i++)
+	    {
+	      g_trash_stack_push (simple_cache + cell, cache_mem);
+	      cache_mem += mem_size;
+	    }
+	  GSL_SPIN_UNLOCK (&global_memory);
+	  mem = cache_mem;
+	}
+    }
+  else
+    {
+      mem = g_malloc (mem_size);
+      GSL_SPIN_LOCK (&global_memory);
+      memory_allocated += mem_size;
+      GSL_SPIN_UNLOCK (&global_memory);
+    }
+  return mem;
+}
+
+static inline void
+low_free (gsize    mem_size,
+	  gpointer mem)
+{
+  if (mem_size >= TS8_SIZE && mem_size / 8 < SIMPLE_CACHE_SIZE)
+    {
+      guint cell;
+
+      mem_size = (mem_size + 7) & ~0x7;
+      cell = (mem_size >> 3) - 1;
+      GSL_SPIN_LOCK (&global_memory);
+      g_trash_stack_push (simple_cache + cell, mem);
+      GSL_SPIN_UNLOCK (&global_memory);
+    }
+  else
+    {
+      g_free (mem);
+      GSL_SPIN_LOCK (&global_memory);
+      memory_allocated -= mem_size;
+      GSL_SPIN_UNLOCK (&global_memory);
+    }
+}
+
+gpointer
+gsl_alloc_memblock (gsize block_size)
+{
+  guint8 *cmem;
+  gsize *debug_size;
+  
+  g_return_val_if_fail (block_size >= sizeof (gpointer), NULL);	/* cache-link size */
+
+  cmem = low_alloc (block_size + DBG8_SIZE);
+  debug_size = (gsize*) cmem;
+  *debug_size = block_size;
+  cmem += DBG8_SIZE;
+
+  return cmem;
+}
+
+void
+gsl_free_memblock (gsize    block_size,
+		   gpointer mem)
+{
+  gsize *debug_size;
+  guint8 *cmem;
+
+  g_return_if_fail (mem != NULL);
+  
+  cmem = mem;
+  cmem -= DBG8_SIZE;
+  debug_size = (gsize*) cmem;
+  g_return_if_fail (block_size == *debug_size);
+
+  low_free (block_size + DBG8_SIZE, cmem);
+}
+
+void
+gsl_alloc_report (void)
+{
+  guint cell, cached = 0;
+
+  GSL_SPIN_LOCK (&global_memory);
+  for (cell = 0; cell < SIMPLE_CACHE_SIZE; cell++)
+    {
+      GTrashStack *trash = simple_cache[cell];
+      guint memsize, n = 0;
+
+      while (trash)
+	{
+	  n++;
+	  trash = trash->next;
+	}
+
+      if (n)
+	{
+	  memsize = (cell + 1) << 3;
+	  g_message ("cell %4u): %u bytes in %u nodes", memsize, memsize * n, n);
+	  cached += memsize * n;
+	}
+    }
+  g_message ("%lu bytes allocated from system, %u bytes unused in cache", memory_allocated, cached);
+  GSL_SPIN_UNLOCK (&global_memory);
+}
+
+gpointer
+gsl_alloc_memblock0 (gsize block_size)
+{
+  gpointer mem = gsl_alloc_memblock (block_size);
+  
+  memset (mem, 0, block_size);
+  
+  return mem;
+}
+
+static void
+gsl_free_node_list (gpointer mem,
+		    gsize    node_size)
+{
+  struct { gpointer next, data; } *tmp, *node = mem;
+
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (node_size >= 2 * sizeof (gpointer));
+
+  /* FIXME: this can be optimized to an O(1) operation with T-style links in mem-caches */
+  do
+    {
+      tmp = node->next;
+
+      gsl_free_memblock (node_size, node);
+      node = tmp;
+    }
+  while (node);
+}
+
+
+/* --- ring (circular-list) --- */
+static inline GslRing*
+gsl_ring_prepend_i (GslRing  *head,
+		    gpointer data)
+{
+  GslRing *ring = gsl_new_struct (GslRing, 1);
+  
+  ring->data = data;
+  if (!head)
+    {
+      ring->prev = ring;
+      ring->next = ring;
+    }
+  else
+    {
+      ring->prev = head->prev;
+      ring->next = head;
+      head->prev->next = ring;
+      head->prev = ring;
+    }
+  return ring;
+}
+
+GslRing*
+gsl_ring_prepend (GslRing  *head,
+		  gpointer data)
+{
+  return gsl_ring_prepend_i (head, data);
+}
+
+GslRing*
+gsl_ring_prepend_uniq (GslRing  *head,
+		       gpointer data)
+{
+  GslRing *walk;
+  
+  for (walk = head; walk; walk = gsl_ring_walk (head, walk))
+    if (walk->data == data)
+      return head;
+  return gsl_ring_prepend_i (head, data);
+}
+
+GslRing*
+gsl_ring_append (GslRing  *head,
+		 gpointer data)
+{
+  GslRing *ring;
+  
+  ring = gsl_ring_prepend_i (head, data);
+  
+  return head ? head : ring;
+}
+
+GslRing*
+gsl_ring_concat (GslRing *head1,
+		 GslRing *head2)
+{
+  GslRing *tail1, *tail2;
+  
+  if (!head1)
+    return head2;
+  if (!head2)
+    return head1;
+  tail1 = head1->prev;
+  tail2 = head2->prev;
+  head1->prev = tail2;
+  tail2->next = head1;
+  head2->prev = tail1;
+  tail1->next = head2;
+  
+  return head1;
+}
+
+GslRing*
+gsl_ring_remove_node (GslRing *head,
+		      GslRing *node)
+{
+  if (!head)
+    g_return_val_if_fail (head == NULL && node == NULL, NULL);
+  if (!head || !node)
+    return NULL;
+  
+  /* special case one item ring */
+  if (head->prev == head)
+    {
+      g_return_val_if_fail (node == head, head);
+      
+      gsl_delete_struct (GslRing, node);
+      return NULL;
+    }
+  g_return_val_if_fail (node != node->next, head); /* node can't be a one item ring here */
+  
+  node->next->prev = node->prev;
+  node->prev->next = node->next;
+  if (head == node)
+    head = node->next;
+  gsl_delete_struct (GslRing, node);
+  
+  return head;
+}
+
+GslRing*
+gsl_ring_remove (GslRing *head,
+		 gpointer data)
+{
+  GslRing *walk;
+
+  if (!head)
+    return NULL;
+  
+  /* make tail data removal an O(1) operation */
+  if (head->prev->data == data)
+    return gsl_ring_remove_node (head, head->prev);
+  
+  for (walk = head; walk; walk = gsl_ring_walk (head, walk))
+    if (walk->data == data)
+      return gsl_ring_remove_node (head, walk);
+  
+  g_warning (G_STRLOC ": couldn't find data item (%p) to remove from ring (%p)", data, head);
+  
+  return head;
+}
+
+guint
+gsl_ring_length (GslRing *head)
+{
+  GslRing *ring;
+  guint i = 0;
+  
+  for (ring = head; ring; ring = gsl_ring_walk (head, ring))
+    i++;
+
+  return i;
+}
+
+GslRing*
+gsl_ring_find (GslRing      *head,
+	       gconstpointer data)
+{
+  GslRing *ring;
+
+  for (ring = head; ring; ring = gsl_ring_walk (head, ring))
+    if (ring->data == (gpointer) data)
+      return ring;
+
+  return NULL;
+}
+
+GslRing*
+gsl_ring_nth (GslRing *head,
+	      guint    n)
+{
+  GslRing *ring = head;
+
+  while (n-- && ring)
+    ring = gsl_ring_walk (head, ring);
+
+  return ring;
+}
+
+gpointer
+gsl_ring_nth_data (GslRing *head,
+		   guint    n)
+{
+  GslRing *ring = head;
+
+  while (n-- && ring)
+    ring = gsl_ring_walk (head, ring);
+
+  return ring ? ring->data : ring;
+}
+
+void
+gsl_ring_free (GslRing *head)
+{
+  if (head)
+    {
+      head->prev->next = NULL;
+      gsl_free_node_list (head, sizeof (*head));
+    }
+}
+
+gpointer
+gsl_ring_pop_head (GslRing **head_p)
+{
+  gpointer data;
+  
+  g_return_val_if_fail (head_p != NULL, NULL);
+  
+  if (!*head_p)
+    return NULL;
+  data = (*head_p)->data;
+  *head_p = gsl_ring_remove_node (*head_p, *head_p);
+  
+  return data;
+}
+
+gpointer
+gsl_ring_pop_tail (GslRing **head_p)
+{
+  gpointer data;
+  
+  g_return_val_if_fail (head_p != NULL, NULL);
+  
+  if (!*head_p)
+    return NULL;
+  data = (*head_p)->prev->data;
+  *head_p = gsl_ring_remove_node (*head_p, (*head_p)->prev);
+  
+  return data;
+}
+
+GslRing*
+gsl_ring_insert_sorted (GslRing	    *head,
+			gpointer     data,
+			GCompareFunc func)
+{
+  gint cmp;
+
+  g_return_val_if_fail (func != NULL, head);
+
+  if (!head)
+    return gsl_ring_prepend (head, data);
+
+  /* typedef gint (*GCompareFunc) (gconstpointer a,
+   *                               gconstpointer b);
+   */
+  cmp = func (data, head->data);
+
+  if (cmp >= 0)	/* insert after head */
+    {
+      GslRing *tmp, *tail = head->prev;
+      
+      /* make appending an O(1) operation */
+      if (head == tail || func (data, tail->data) >= 0)
+	return gsl_ring_append (head, data);
+
+      /* walk forward while data >= tmp (skipping equal nodes) */
+      for (tmp = head->next; tmp != tail; tmp = tmp->next)
+	if (func (data, tmp->data) < 0)
+	  break;
+
+      /* insert before sibling which is greater than data */
+      gsl_ring_prepend (tmp, data);	/* keep current head */
+      return head;
+    }
+  else /* cmp < 0 */
+    return gsl_ring_prepend (head, data);
+}
+
+
+/* --- GslThread --- */
+typedef struct
+{
+  GslThreadFunc func;
+  gpointer      data;
+  gint		wpipe[2];
+  volatile gint abort;
+  guint64       awake_stamp;
+  GslDebugFlags auxlog_reporter;
+  const gchar  *auxlog_section;
+} ThreadData;
+static GslMutex    global_thread = { 0, };
+static GslRing    *global_thread_list = NULL;
+static GslCond     global_thread_cond = { 0, };
+static GslRing    *awake_tdata_list = NULL;
+static ThreadData *main_thread_tdata = NULL;
+static GslThread  *main_thread = NULL;
+
+static inline ThreadData*
+thread_data_from_gsl_thread (GslThread *thread)
+{
+  GThread *gthread = (GThread*) thread;
+
+  /* if gthread->data==NULL, we assume this is the main thread */
+
+  return gthread->data ? gthread->data : main_thread_tdata;
+}
+
+static gpointer
+thread_wrapper (gpointer arg)
+{
+  GslThread *self = gsl_thread_self ();
+  ThreadData *tdata = arg;
+
+  g_assert (tdata == thread_data_from_gsl_thread (gsl_thread_self ()));
+
+  GSL_SYNC_LOCK (&global_thread);
+  global_thread_list = gsl_ring_prepend (global_thread_list, self);
+  gsl_cond_broadcast (&global_thread_cond);
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  tdata->func (tdata->data);
+
+  GSL_SYNC_LOCK (&global_thread);
+  global_thread_list = gsl_ring_remove (global_thread_list, self);
+  if (tdata->awake_stamp)
+    awake_tdata_list = gsl_ring_remove (awake_tdata_list, tdata);
+  gsl_cond_broadcast (&global_thread_cond);
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  close (tdata->wpipe[0]);
+  tdata->wpipe[0] = -1;
+  close (tdata->wpipe[1]);
+  tdata->wpipe[1] = -1;
+  gsl_delete_struct (ThreadData, tdata);
+  
+  return NULL;
+}
+
+static ThreadData*
+create_tdata (void)
+{
+  ThreadData *tdata;
+  glong d_long;
+  gint error;
+
+  tdata = gsl_new_struct0 (ThreadData, 1);
+  tdata->func = NULL;
+  tdata->data = NULL;
+  tdata->wpipe[0] = -1;
+  tdata->wpipe[1] = -1;
+  tdata->abort = FALSE;
+  tdata->auxlog_reporter = 0;
+  tdata->auxlog_section = NULL;
+  error = pipe (tdata->wpipe);
+  if (error == 0)
+    {
+      d_long = fcntl (tdata->wpipe[0], F_GETFL, 0);
+      /* g_printerr ("pipe-readfd, blocking=%ld\n", d_long & O_NONBLOCK); */
+      d_long |= O_NONBLOCK;
+      error = fcntl (tdata->wpipe[0], F_SETFL, d_long);
+    }
+  if (error == 0)
+    {
+      d_long = fcntl (tdata->wpipe[1], F_GETFL, 0);
+      /* g_printerr ("pipe-writefd, blocking=%ld\n", d_long & O_NONBLOCK); */
+      d_long |= O_NONBLOCK;
+      error = fcntl (tdata->wpipe[1], F_SETFL, d_long);
+    }
+  if (error)
+    {
+      close (tdata->wpipe[0]);
+      close (tdata->wpipe[1]);
+      gsl_delete_struct (ThreadData, tdata);
+      tdata = NULL;
+    }
+  return tdata;
+}
+
+GslThread*
+gsl_thread_new (GslThreadFunc func,
+		gpointer      user_data)
+{
+  gpointer gthread = NULL;
+  ThreadData *tdata;
+  GError *gerror = NULL;
+
+  g_return_val_if_fail (func != NULL, FALSE);
+
+  tdata = create_tdata ();
+
+  if (tdata)
+    {
+      const gboolean joinable = FALSE;
+
+      /* don't dare setting joinable to TRUE, that prevents the thread's
+       * resources from being freed, since we don't offer pthread_join().
+       * so we'd just rn out of stack at some point.
+       */
+      tdata->func = func;
+      tdata->data = user_data;
+      gthread = g_thread_create_full (thread_wrapper, tdata, 0, joinable, FALSE,
+				      G_THREAD_PRIORITY_NORMAL, &gerror);
+    }
+
+  if (gthread)
+    {
+      GSL_SYNC_LOCK (&global_thread);
+      while (!gsl_ring_find (global_thread_list, gthread))
+	gsl_cond_wait (&global_thread_cond, &global_thread);
+      GSL_SYNC_UNLOCK (&global_thread);
+    }
+  else
+    {
+      if (tdata)
+	{
+	  close (tdata->wpipe[0]);
+	  close (tdata->wpipe[1]);
+	  gsl_delete_struct (ThreadData, tdata);
+	}
+      g_warning ("Failed to create thread: %s", gerror->message);
+      g_error_free (gerror);
+    }
+
+  return gthread;
+}
+
+GslThread*
+gsl_thread_self (void)
+{
+  gpointer gthread = g_thread_self ();
+
+  if (!gthread)
+    g_error ("gsl_thread_self() failed");
+
+  return gthread;
+}
+
+GslThread*
+gsl_thread_main (void)
+{
+  return main_thread;
+}
+
+guint
+gsl_threads_get_count (void)
+{
+  guint count;
+
+  GSL_SYNC_LOCK (&global_thread);
+  count = gsl_ring_length (global_thread_list);
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  return count;
+}
+
+static void
+thread_wakeup_I (ThreadData *tdata)
+{
+  guint8 data = 'W';
+  gint r;
+
+  do
+    r = write (tdata->wpipe[1], &data, 1);
+  while (r < 0 && (errno == EINTR || errno == ERESTART));
+}
+
+/**
+ * gsl_thread_wakeup
+ * @thread: thread to wake up
+ * Wake up a currently sleeping thread. In practice, this
+ * function simply causes the next call to gsl_thread_sleep()
+ * within @thread to last for 0 seconds.
+ */
+void
+gsl_thread_wakeup (GslThread *thread)
+{
+  ThreadData *tdata;
+
+  g_return_if_fail (thread != NULL);
+
+  GSL_SYNC_LOCK (&global_thread);
+  g_assert (gsl_ring_find (global_thread_list, thread));
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  tdata = thread_data_from_gsl_thread (thread);
+  thread_wakeup_I (tdata);
+}
+
+/**
+ * gsl_thread_abort
+ * @thread: thread to abort
+ * Abort a currently running thread. This function does not
+ * return until the thread in question terminated execution.
+ * Note that the thread handle gets invalidated with invocation
+ * of gsl_thread_abort() or gsl_thread_queue_abort().
+ */
+void
+gsl_thread_abort (GslThread *thread)
+{
+  ThreadData *tdata;
+  
+  g_return_if_fail (thread != NULL);
+  g_return_if_fail (thread != main_thread);
+  
+  GSL_SYNC_LOCK (&global_thread);
+  g_assert (gsl_ring_find (global_thread_list, thread));
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  tdata = thread_data_from_gsl_thread (thread);
+
+  GSL_SYNC_LOCK (&global_thread);
+  tdata->abort = TRUE;
+  thread_wakeup_I (tdata);
+
+  while (gsl_ring_find (global_thread_list, thread))
+    gsl_cond_wait (&global_thread_cond, &global_thread);
+  GSL_SYNC_UNLOCK (&global_thread);
+}
+
+/**
+ * gsl_thread_queue_abort
+ * @thread: thread to abort
+ * Same as gsl_thread_abort(), but returns as soon as possible,
+ * even if thread hasn't stopped execution yet.
+ * Note that the thread handle gets invalidated with invocation
+ * of gsl_thread_abort() or gsl_thread_queue_abort().
+ */
+void
+gsl_thread_queue_abort (GslThread *thread)
+{
+  ThreadData *tdata;
+  
+  g_return_if_fail (thread != NULL);
+  g_return_if_fail (thread != main_thread);
+  
+  GSL_SYNC_LOCK (&global_thread);
+  g_assert (gsl_ring_find (global_thread_list, thread));
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  tdata = thread_data_from_gsl_thread (thread);
+
+  GSL_SYNC_LOCK (&global_thread);
+  tdata->abort = TRUE;
+  thread_wakeup_I (tdata);
+  GSL_SYNC_UNLOCK (&global_thread);
+}
+
+/**
+ * gsl_thread_aborted
+ * @returns: %TRUE if the thread should abort execution
+ * Find out if the currently running thread should be aborted (the thread is
+ * supposed to return from its main thread function).
+ */
+gboolean
+gsl_thread_aborted (void)
+{
+  ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+  gboolean aborted;
+
+  GSL_SYNC_LOCK (&global_thread);
+  aborted = tdata->abort != FALSE;
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  return aborted;
+}
+
+/**
+ * gsl_thread_sleep
+ * @max_msec: maximum amount of milli seconds to sleep (-1 for infinite time)
+ * @returns:  %TRUE if the thread should continue execution
+ * Sleep for the amount of time given. This function may get interrupted
+ * by wakeup or abort requests, it returns whether the thread is supposed
+ * to continue execution after waking up. This function also processes
+ * remaining data from the thread's poll fd.
+ */
+gboolean
+gsl_thread_sleep (glong max_msec)
+{
+  ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+  struct pollfd pfd;
+  gint r, aborted;
+
+  pfd.fd = tdata->wpipe[0];
+  pfd.events = G_IO_IN;
+  pfd.revents = 0;
+
+  r = poll (&pfd, 1, max_msec);
+
+  if (r < 0 && errno != EINTR)
+    g_message (G_STRLOC ": poll() error: %s\n", g_strerror (errno));
+  else if (pfd.revents & G_IO_IN)
+    {
+      guint8 data[64];
+
+      do
+	r = read (tdata->wpipe[0], data, sizeof (data));
+      while ((r < 0 && (errno == EINTR || errno == ERESTART)) || r == sizeof (data));
+    }
+
+  GSL_SYNC_LOCK (&global_thread);
+  aborted = tdata->abort != FALSE;
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  return !aborted;
+}
+
+/**
+ * gsl_thread_awake_after
+ * RETURNS: GPollFD for the current thread
+ * Get the GPollfd for the current thread which is used
+ * to signal thread wakeups (e.g. due to
+ * gsl_thread_abort() or gsl_thread_wakeup()).
+ */
+void
+gsl_thread_get_pollfd (GPollFD *pfd)
+{
+  ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+
+  pfd->fd = tdata->wpipe[0];
+  pfd->events = G_IO_IN;
+  pfd->revents = 0;
+}
+
+/**
+ * gsl_thread_awake_after
+ * @tick_stamp: tick stamp update to trigger wakeup
+ * Wakeup the currently running thread after the global tick stamp
+ * (see gsl_tick_stamp()) has been updated to @tick_stamp.
+ * (If the moment of wakeup has already passed by, the thread is
+ * woken up at the next global tick stamp update.)
+ */
+void
+gsl_thread_awake_after (guint64 tick_stamp)
+{
+  ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+
+  g_return_if_fail (tick_stamp > 0);
+
+  GSL_SYNC_LOCK (&global_thread);
+  if (!tdata->awake_stamp)
+    {
+      awake_tdata_list = gsl_ring_prepend (awake_tdata_list, tdata);
+      tdata->awake_stamp = tick_stamp;
+    }
+  else
+    tdata->awake_stamp = MIN (tdata->awake_stamp, tick_stamp);
+  GSL_SYNC_UNLOCK (&global_thread);
+}
+
+/**
+ * gsl_thread_awake_before
+ * @tick_stamp: tick stamp update to trigger wakeup
+ * Wakeup the currently running thread upon the last global tick stamp
+ * update (see gsl_tick_stamp()) that happens prior to updating the
+ * global tick stamp to @tick_stamp.
+ * (If the moment of wakeup has already passed by, the thread is
+ * woken up at the next global tick stamp update.)
+ */
+void
+gsl_thread_awake_before (guint64 tick_stamp)
+{
+  g_return_if_fail (tick_stamp > 0);
+
+  if (tick_stamp > global_tick_stamp_leaps)
+    gsl_thread_awake_after (tick_stamp - global_tick_stamp_leaps);
+  else
+    gsl_thread_awake_after (tick_stamp);
+}
+
+/**
+ * gsl_tick_stamp
+ * @RETURNS: GSL's execution tick stamp as unsigned 64bit integer
+ *
+ * Retrive the GSL global tick stamp.
+ * GSL increments its global tick stamp at certain intervals,
+ * by specific amounts (refer to gsl_engine_init() for further
+ * details). The tick stamp is a non-wrapping, unsigned 64bit
+ * integer greater than 0. Threads can schedule sleep interruptions
+ * at certain tick stamps with gsl_thread_awake_after() and
+ * gsl_thread_awake_before(). Tick stamp updating occours at
+ * GSL engine block processing boundaries, so code that can
+ * guarantee to not run across those boundaries (for instance
+ * GslProcessFunc() functions) may use the macro %GSL_TICK_STAMP
+ * to retrive the current tick in a faster manner (not involving
+ * mutex locking). See also gsl_module_tick_stamp().
+ * This function is MT-safe and may be called from any thread.
+ */
+guint64
+gsl_tick_stamp (void)
+{
+  guint64 stamp;
+
+  GSL_SYNC_LOCK (&global_thread);
+  stamp = gsl_externvar_tick_stamp;
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  return stamp;
+}
+
+void
+_gsl_tick_stamp_set_leap (guint ticks)
+{
+  GSL_SYNC_LOCK (&global_thread);
+  global_tick_stamp_leaps = ticks;
+  GSL_SYNC_UNLOCK (&global_thread);
+}
+
+/**
+ * gsl_time_system
+ * @RETURNS: Current system time in micro seconds
+ *
+ * Get the current system time in micro seconds.
+ * Subsequent calls to this function do not necessarily
+ * return growing values. In fact, a second call may return
+ * a value smaller than the first call under certainsystem
+ * conditions.
+ * This function is MT-safe and may be called from any thread.
+ */
+guint64
+gsl_time_system (void)
+{
+  struct timeval tv;
+  guint64 csys_time;
+  gint error;
+
+  error = gettimeofday (&tv, NULL);
+  if (error)
+    g_error ("gettimeofday() failed: %s", g_strerror (errno));
+  csys_time = tv.tv_sec;
+  csys_time = csys_time * 1000000 + tv.tv_usec;
+
+  return csys_time;
+}
+
+/**
+ * gsl_tick_stamp_last
+ * @RETURNS: Current tick stamp and system time in micro seconds
+ *
+ * Get the system time of the last GSL global tick stamp update.
+ * This function is MT-safe and may be called from any thread.
+ */
+GslTickStampUpdate
+gsl_tick_stamp_last (void)
+{
+  GslTickStampUpdate ustamp;
+
+  GSL_SYNC_LOCK (&global_thread);
+  ustamp.tick_stamp = gsl_externvar_tick_stamp;
+  ustamp.system_time = tick_stamp_system_time;
+  GSL_SYNC_UNLOCK (&global_thread);
+
+  return ustamp;
+}
+
+void
+_gsl_tick_stamp_inc (void)
+{
+  volatile guint64 newstamp;
+  GslRing *ring;
+  guint64 systime;
+
+  g_return_if_fail (global_tick_stamp_leaps > 0);
+
+  systime = gsl_time_system ();
+  newstamp = gsl_externvar_tick_stamp + global_tick_stamp_leaps;
+
+  GSL_SYNC_LOCK (&global_thread);
+  gsl_externvar_tick_stamp = newstamp;
+  tick_stamp_system_time = systime;
+  for (ring = awake_tdata_list; ring; )
+    {
+      ThreadData *tdata = ring->data;
+
+      if (tdata->awake_stamp <= GSL_TICK_STAMP)
+	{
+	  GslRing *next = gsl_ring_walk (awake_tdata_list, ring);
+
+	  tdata->awake_stamp = 0;
+	  awake_tdata_list = gsl_ring_remove (awake_tdata_list, tdata);
+
+	  thread_wakeup_I (tdata);
+	  ring = next;
+	}
+      else
+	ring = gsl_ring_walk (awake_tdata_list, ring);
+    }
+  GSL_SYNC_UNLOCK (&global_thread);
+}
+
+
+/* --- GslMutex --- */
+static gboolean is_smp_system = FALSE;
+
+static void
+default_mutex_init (GslMutex *mutex)
+{
+  g_return_if_fail (mutex != NULL);
+  
+  mutex->mutex_pointer = g_mutex_new ();
+}
+
+static int
+default_mutex_trylock (GslMutex *mutex)
+{
+  return g_mutex_trylock (mutex->mutex_pointer) ? 0 : -1;
+}
+
+static void
+default_mutex_lock (GslMutex *mutex)
+{
+  /* spin locks should be held only very short times,
+   * so frequently we should succeed here
+   */
+  if (g_mutex_trylock (mutex->mutex_pointer))
+    return;
+
+  if (!is_smp_system)
+    {
+      /* on uni processor systems, there's no point in busy spinning */
+      do
+	{
+#if defined(_POSIX_PRIORITY_SCHEDULING)
+	  sched_yield ();
+#endif
+	  if (g_mutex_trylock (mutex->mutex_pointer))
+	    return;
+	}
+      while (TRUE);
+    }
+  else
+    {
+      /* for multi processor systems, mutex_lock() is hopefully implemented
+       * via spinning. note that we can't implement spinning ourselves with
+       * mutex_trylock(), since on some architectures that'd block memory
+       * bandwith due to constant bus locks
+       */
+      g_mutex_lock (mutex->mutex_pointer);
+    }
+}
+
+static void
+default_mutex_unlock (GslMutex *mutex)
+{
+  g_mutex_unlock (mutex->mutex_pointer);
+}
+
+static void
+default_mutex_destroy (GslMutex *mutex)
+{
+  g_mutex_free (mutex->mutex_pointer);
+  memset (mutex, 0, sizeof (*mutex));
+}
+
+static void
+default_rec_mutex_init (GslRecMutex *rec_mutex)
+{
+  rec_mutex->depth = 0;
+  rec_mutex->owner = NULL;
+  gsl_mutex_init (&rec_mutex->sync_mutex);
+}
+
+static int
+default_rec_mutex_trylock (GslRecMutex *rec_mutex)
+{
+  gpointer self = gsl_thread_self ();
+
+  if (rec_mutex->owner == self)
+    {
+      g_assert (rec_mutex->depth > 0);  /* paranoid */
+      rec_mutex->depth += 1;
+      return 0;
+    }
+  else
+    {
+      if (gsl_mutex_trylock (&rec_mutex->sync_mutex))
+	{
+	  g_assert (rec_mutex->owner == NULL && rec_mutex->depth == 0); /* paranoid */
+	  rec_mutex->owner = self;
+	  rec_mutex->depth = 1;
+	  return 0;
+	}
+    }
+  return -1;
+}
+
+static void
+default_rec_mutex_lock (GslRecMutex *rec_mutex)
+{
+  gpointer self = gsl_thread_self ();
+
+  if (rec_mutex->owner == self)
+    {
+      g_assert (rec_mutex->depth > 0);  /* paranoid */
+      rec_mutex->depth += 1;
+    }
+  else
+    {
+      GSL_SYNC_LOCK (&rec_mutex->sync_mutex);
+      g_assert (rec_mutex->owner == NULL && rec_mutex->depth == 0); /* paranoid */
+      rec_mutex->owner = self;
+      rec_mutex->depth = 1;
+    }
+}
+
+static void
+default_rec_mutex_unlock (GslRecMutex *rec_mutex)
+{
+  gpointer self = gsl_thread_self ();
+
+  if (rec_mutex->owner == self && rec_mutex->depth > 0)
+    {
+      rec_mutex->depth -= 1;
+      if (!rec_mutex->depth)
+	{
+	  rec_mutex->owner = NULL;
+	  GSL_SYNC_UNLOCK (&rec_mutex->sync_mutex);
+	}
+    }
+  else
+    g_warning ("unable to unlock recursive mutex with self %p != %p or depth %u < 1",
+	       rec_mutex->owner, self, rec_mutex->depth);
+}
+
+static void
+default_rec_mutex_destroy (GslRecMutex *rec_mutex)
+{
+  if (rec_mutex->owner || rec_mutex->depth)
+    {
+      g_warning (G_STRLOC ": recursive mutex still locked during destruction");
+      return;
+    }
+  gsl_mutex_destroy (&rec_mutex->sync_mutex);
+  g_assert (rec_mutex->owner == NULL && rec_mutex->depth == 0);
+}
+
+static void
+default_cond_init (GslCond *cond)
+{
+  cond->cond_pointer = g_cond_new ();
+}
+
+static void
+default_cond_wait (GslCond  *cond,
+		   GslMutex *mutex)
+{
+  /* infinite wait */
+  g_cond_wait (cond->cond_pointer, mutex->mutex_pointer);
+}
+
+static void
+default_cond_signal (GslCond *cond)
+{
+  g_cond_signal (cond->cond_pointer);
+}
+
+static void
+default_cond_broadcast (GslCond *cond)
+{
+  g_cond_broadcast (cond->cond_pointer);
+}
+
+static void
+default_cond_destroy (GslCond *cond)
+{
+  g_cond_free (cond->cond_pointer);
+}
+
+static void
+default_cond_wait_timed (GslCond  *cond,
+			 GslMutex *mutex,
+			 gulong    abs_secs,
+			 gulong    abs_usecs)
+{
+  GTimeVal gtime;
+
+  gtime.tv_sec = abs_secs;
+  gtime.tv_usec = abs_usecs;
+  g_cond_timed_wait (cond->cond_pointer, mutex->mutex_pointer, &gtime);
+}
+
+GslMutexTable gsl_mutex_table = {
+  default_mutex_init,
+  default_mutex_lock,
+  default_mutex_trylock,
+  default_mutex_unlock,
+  default_mutex_destroy,
+  default_rec_mutex_init,
+  default_rec_mutex_lock,
+  default_rec_mutex_trylock,
+  default_rec_mutex_unlock,
+  default_rec_mutex_destroy,
+  default_cond_init,
+  default_cond_signal,
+  default_cond_broadcast,
+  default_cond_wait,
+  default_cond_wait_timed,
+  default_cond_destroy,
+};
+
+void
+gsl_cond_wait_timed (GslCond  *cond,
+		     GslMutex *mutex,
+		     glong     max_useconds)
+{
+  if (max_useconds < 0)
+    gsl_cond_wait (cond, mutex);
+  else
+    {
+      struct timeval now;
+      glong secs;
+
+      gettimeofday (&now, NULL);
+      secs = max_useconds / 1000000;
+      now.tv_sec += secs;
+      max_useconds -= secs * 1000000;
+      now.tv_usec += max_useconds;
+      if (now.tv_usec >= 1000000)
+	{
+	  now.tv_usec -= 1000000;
+	  now.tv_sec += 1;
+	}
+
+      /* linux on x86 with pthread has actually 10ms resolution */
+      gsl_mutex_table.cond_wait_timed (cond, mutex, now.tv_sec, now.tv_usec);
+    }
+}
+
+
+/* --- GslMessage --- */
+const gchar*
+gsl_strerror (GslErrorType error)
+{
+  switch (error)
+    {
+    case GSL_ERROR_NONE:		return "Everything went well";
+    case GSL_ERROR_INTERNAL:		return "Internal error (please report)";
+    case GSL_ERROR_UNKNOWN:		return "Unknown error";
+    case GSL_ERROR_IO:			return "I/O error";
+    case GSL_ERROR_PERMS:		return "Insufficient permission";
+    case GSL_ERROR_BUSY:		return "Resource currently busy";
+    case GSL_ERROR_EXISTS:		return "Resource exists already";
+    case GSL_ERROR_TEMP:		return "Temporary error";
+    case GSL_ERROR_EOF:			return "File empty or premature EOF";
+    case GSL_ERROR_NOT_FOUND:		return "Resource not found";
+    case GSL_ERROR_OPEN_FAILED:		return "Open failed";
+    case GSL_ERROR_SEEK_FAILED:		return "Seek failed";
+    case GSL_ERROR_READ_FAILED:		return "Read failed";
+    case GSL_ERROR_WRITE_FAILED:	return "Write failed";
+    case GSL_ERROR_FORMAT_INVALID:	return "Invalid format";
+    case GSL_ERROR_FORMAT_UNKNOWN:	return "Unknown format";
+    case GSL_ERROR_DATA_CORRUPT:        return "Data corrupt";
+    case GSL_ERROR_CONTENT_GLITCH:      return "Data glitch (junk) detected";
+    case GSL_ERROR_NO_RESOURCE:		return "Out of memory, disk space or similar resource";
+    case GSL_ERROR_CODEC_FAILURE:	return "CODEC failure";
+    default:				return NULL;
+    }
+}
+
+static const GDebugKey gsl_static_debug_keys[] = {
+  { "notify",         GSL_MSG_NOTIFY },
+  { "dcache",         GSL_MSG_DATA_CACHE },
+  { "dhandle",        GSL_MSG_DATA_HANDLE },
+  { "loader",         GSL_MSG_LOADER },
+  { "osc",	      GSL_MSG_OSC },
+  { "engine",         GSL_MSG_ENGINE },
+  { "jobs",           GSL_MSG_JOBS },
+  { "fjobs",          GSL_MSG_FJOBS },
+  { "sched",          GSL_MSG_SCHED },
+  { "master",         GSL_MSG_MASTER },
+  { "slave",          GSL_MSG_SLAVE },
+};
+
+static const gchar*
+reporter_name (GslDebugFlags reporter)
+{
+  switch (reporter)
+    {
+    case GSL_MSG_NOTIFY:	return "Notify";
+    case GSL_MSG_DATA_CACHE:	return "DataCache";
+    case GSL_MSG_DATA_HANDLE:	return "DataHandle";
+    case GSL_MSG_LOADER:	return "Loader";
+    case GSL_MSG_OSC:		return "Oscillator";
+    case GSL_MSG_ENGINE:	return "Engine";	/* Engine */
+    case GSL_MSG_JOBS:		return "Jobs";		/* Engine */
+    case GSL_MSG_FJOBS:		return "FlowJobs";	/* Engine */
+    case GSL_MSG_SCHED:		return "Sched";		/* Engine */
+    case GSL_MSG_MASTER:	return "Master";	/* Engine */
+    case GSL_MSG_SLAVE:		return "Slave";		/* Engine */
+    default:			return "Custom";
+    }
+}
+
+const GDebugKey *gsl_debug_keys = gsl_static_debug_keys;
+const guint      gsl_n_debug_keys = G_N_ELEMENTS (gsl_static_debug_keys);
+
+void
+gsl_message_send (GslDebugFlags reporter,
+		  const gchar  *section,
+		  GslErrorType  error,
+		  const gchar  *messagef,
+		  ...)
+{
+  struct {
+    GslDebugFlags reporter;
+    gchar         reporter_name[64];
+    gchar         section[64];	/* auxillary information about reporter code portion */
+    GslErrorType  error;
+    const gchar	 *error_str;	/* gsl_strerror() of error */
+    gchar	  message[1024];
+  } tmsg, *msg = &tmsg;
+  gchar *string;
+  va_list args;
+    
+  g_return_if_fail (messagef != NULL);
+
+  /* create message */
+  memset (msg, 0, sizeof (*msg));
+  msg->reporter = reporter;
+  strncpy (msg->reporter_name, reporter_name (msg->reporter), 63);
+  if (section)
+    strncpy (msg->section, section, 63);
+  msg->error = error;
+  msg->error_str = error ? gsl_strerror (msg->error) : NULL;
+
+  /* vsnprintf() replacement */
+  va_start (args, messagef);
+  string = g_strdup_vprintf (messagef, args);
+  va_end (args);
+  strncpy (msg->message, string, 1023);
+  g_free (string);
+
+  /* in current lack of a decent message queue, puke the message to stderr */
+  g_printerr ("GSL-%s%s%s: %s%s%s\n",
+	      msg->reporter_name,
+	      msg->section ? ":" : "",
+	      msg->section ? msg->section : "",
+	      msg->message,
+	      msg->error_str ? ": " : "",
+	      msg->error_str ? msg->error_str : "");
+}
+
+void
+gsl_debug_enable (GslDebugFlags dbg_flags)
+{
+  gsl_debug_flags |= dbg_flags;
+}
+
+void
+gsl_debug_disable (GslDebugFlags dbg_flags)
+{
+  gsl_debug_flags &= dbg_flags;
+}
+
+gboolean
+gsl_debug_check (GslDebugFlags dbg_flags)
+{
+  return (gsl_debug_flags & dbg_flags) != 0;
+}
+
+void
+gsl_debug (GslDebugFlags reporter,
+	   const gchar  *section,
+	   const gchar  *format,
+	   ...)
+{
+  g_return_if_fail (format != NULL);
+
+  if (reporter & gsl_debug_flags)
+    {
+      va_list args;
+      gchar *string;
+
+      va_start (args, format);
+      string = g_strdup_vprintf (format, args);
+      va_end (args);
+      g_printerr ("DEBUG:GSL-%s%s%s: %s\n",
+		  reporter_name (reporter),
+		  section ? ":" : "",
+		  section ? section : "",
+		  string);
+      g_free (string);
+    }
+}
+
+void
+gsl_auxlog_push (GslDebugFlags reporter,
+		 const gchar  *section)
+{
+  ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+
+  if (tdata)
+    {
+      tdata->auxlog_reporter = reporter;
+      tdata->auxlog_section = section;
+    }
+}
+
+void
+gsl_auxlog_debug (const gchar *format,
+		  ...)
+{
+  ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+  GslDebugFlags reporter = GSL_MSG_NOTIFY;
+  const gchar *section = NULL;
+  va_list args;
+  gchar *string;
+
+  if (tdata)
+    {
+      reporter = tdata->auxlog_reporter;
+      section = tdata->auxlog_section;
+      tdata->auxlog_reporter = 0;
+      tdata->auxlog_section = NULL;
+    }
+
+  g_return_if_fail (format != NULL);
+
+  va_start (args, format);
+  string = g_strdup_vprintf (format, args);
+  va_end (args);
+  gsl_debug (reporter, section, "%s", string);
+  g_free (string);
+}
+
+void
+gsl_auxlog_message (GslErrorType error,
+		    const gchar *format,
+		    ...)
+{
+  ThreadData *tdata = thread_data_from_gsl_thread (gsl_thread_self ());
+  GslDebugFlags reporter = GSL_MSG_NOTIFY;
+  const gchar *section = NULL;
+  va_list args;
+  gchar *string;
+
+  if (tdata)
+    {
+      reporter = tdata->auxlog_reporter;
+      section = tdata->auxlog_section;
+      tdata->auxlog_reporter = 0;
+      tdata->auxlog_section = NULL;
+    }
+
+  g_return_if_fail (format != NULL);
+
+  va_start (args, format);
+  string = g_strdup_vprintf (format, args);
+  va_end (args);
+  gsl_message_send (reporter, section, error, "%s", string);
+  g_free (string);
+}
+
+
+/* --- misc --- */
+const gchar*
+gsl_byte_order_to_string (guint byte_order)
+{
+  g_return_val_if_fail (byte_order == G_LITTLE_ENDIAN || byte_order == G_BIG_ENDIAN, NULL);
+
+  if (byte_order == G_LITTLE_ENDIAN)
+    return "little_endian";
+  if (byte_order == G_BIG_ENDIAN)
+    return "big_endian";
+
+  return NULL;
+}
+
+guint
+gsl_byte_order_from_string (const gchar *string)
+{
+  g_return_val_if_fail (string != NULL, 0);
+
+  while (*string == ' ')
+    string++;
+  if (strncasecmp (string, "little", 6) == 0)
+    return G_LITTLE_ENDIAN;
+  if (strncasecmp (string, "big", 3) == 0)
+    return G_BIG_ENDIAN;
+  return 0;
+}
+
+GslErrorType
+gsl_check_file (const gchar *file_name,
+		const gchar *mode)
+{
+  guint access_mask = 0;
+  guint check_file, check_dir, check_link;
+  
+  if (strchr (mode, 'r'))	/* readable */
+    access_mask |= R_OK;
+  if (strchr (mode, 'w'))	/* writable */
+    access_mask |= W_OK;
+  if (strchr (mode, 'x'))	/* executable */
+    access_mask |= X_OK;
+
+  if (access_mask && access (file_name, access_mask) < 0)
+    goto have_errno;
+  
+  check_file = strchr (mode, 'f') != NULL;	/* open as file */
+  check_dir  = strchr (mode, 'd') != NULL;	/* open as directory */
+  check_link = strchr (mode, 'l') != NULL;	/* open as link */
+
+  if (check_file || check_dir || check_link)
+    {
+      struct stat st;
+      
+      if (check_link)
+	{
+	  if (lstat (file_name, &st) < 0)
+	    goto have_errno;
+	}
+      else if (stat (file_name, &st) < 0)
+	goto have_errno;
+
+      if ((check_file && !S_ISREG (st.st_mode)) ||
+	  (check_dir && !S_ISDIR (st.st_mode)) ||
+	  (check_link && !S_ISLNK (st.st_mode)))
+	return GSL_ERROR_OPEN_FAILED;
+    }
+
+  return GSL_ERROR_NONE;
+  
+ have_errno:
+  return gsl_error_from_errno (errno, GSL_ERROR_OPEN_FAILED);
+}
+
+GslErrorType
+gsl_error_from_errno (gint         sys_errno,
+		      GslErrorType fallback)
+{
+  switch (sys_errno)
+    {
+    case ELOOP:
+    case ENAMETOOLONG:
+    case ENOTDIR:
+    case ENOENT:        return GSL_ERROR_NOT_FOUND;
+    case EROFS:
+    case EPERM:
+    case EACCES:        return GSL_ERROR_PERMS;
+    case ENOMEM:
+    case ENOSPC:
+    case EFBIG:
+    case ENFILE:
+    case EMFILE:	return GSL_ERROR_NO_RESOURCE;
+    case EISDIR:
+    case ESPIPE:
+    case EIO:           return GSL_ERROR_IO;
+    case EEXIST:        return GSL_ERROR_EXISTS;
+    case ETXTBSY:
+    case EBUSY:         return GSL_ERROR_BUSY;
+    case EAGAIN:
+    case EINTR:		return GSL_ERROR_TEMP;
+    case EINVAL:
+    case EFAULT:
+    case EBADF:         return GSL_ERROR_INTERNAL;
+    default:            return fallback;
+    }
+}
+
+
+/* --- global initialization --- */
+static guint
+get_n_processors (void)
+{
+#ifdef _SC_NPROCESSORS_ONLN
+  {
+    gint n = sysconf (_SC_NPROCESSORS_ONLN);
+
+    if (n > 0)
+      return n;
+  }
+#endif
+  return 1;
+}
+
+static const GslConfig *gsl_config = NULL;
+
+const GslConfig*
+gsl_get_config (void)
+{
+  return gsl_config;
+}
+
+#define	ROUND(dblval)	((GslLong) ((dblval) + .5))
+
+void
+gsl_init (const GslConfigValue values[],
+	  GslMutexTable       *mtable)
+{
+  const GslConfigValue *config = values;
+  static GslConfig pconfig = {	/* DEFAULTS */
+    1,				/* n_processors */
+    2,				/* wave_chunk_padding */
+    4,				/* wave_chunk_big_pad */
+    512,			/* dcache_block_size */
+    1024 * 1024,		/* dcache_cache_memory */
+    69,				/* midi_kammer_note */
+    440,			/* kammer_freq */
+  };
+
+  g_return_if_fail (gsl_config == NULL);	/* assert single initialization */
+
+  /* get mutexes going first */
+  if (mtable)
+    gsl_mutex_table = *mtable;
+
+  gsl_externvar_tick_stamp = 1;
+
+  /* configure permanent config record */
+  if (config)
+    while (config->value_name)
+      {
+	if (strcmp ("wave_chunk_padding", config->value_name) == 0)
+	  pconfig.wave_chunk_padding = ROUND (config->value);
+	else if (strcmp ("wave_chunk_big_pad", config->value_name) == 0)
+	  pconfig.wave_chunk_big_pad = ROUND (config->value);
+	else if (strcmp ("dcache_cache_memory", config->value_name) == 0)
+	  pconfig.dcache_cache_memory = ROUND (config->value);
+	else if (strcmp ("dcache_block_size", config->value_name) == 0)
+	  pconfig.dcache_block_size = ROUND (config->value);
+	else if (strcmp ("midi_kammer_note", config->value_name) == 0)
+	  pconfig.midi_kammer_note = ROUND (config->value);
+	else if (strcmp ("kammer_freq", config->value_name) == 0)
+	  pconfig.kammer_freq = config->value;
+	config++;
+      }
+  
+  /* constrain (user) config */
+  pconfig.wave_chunk_padding = MAX (1, pconfig.wave_chunk_padding);
+  pconfig.wave_chunk_big_pad = MAX (2 * pconfig.wave_chunk_padding, pconfig.wave_chunk_big_pad);
+  pconfig.dcache_block_size = MAX (2 * pconfig.wave_chunk_big_pad + sizeof (GslDataType), pconfig.dcache_block_size);
+  pconfig.dcache_block_size = gsl_alloc_upper_power2 (pconfig.dcache_block_size - 1);
+  /* pconfig.dcache_cache_memory = gsl_alloc_upper_power2 (pconfig.dcache_cache_memory); */
+
+  /* non-configurable config updates */
+  pconfig.n_processors = get_n_processors ();
+
+  /* export GSL configuration */
+  gsl_config = &pconfig;
+
+  /* initialize subsystems */
+  is_smp_system = GSL_CONFIG (n_processors) > 1;
+  gsl_mutex_init (&global_memory);
+  gsl_mutex_init (&global_thread);
+  gsl_cond_init (&global_thread_cond);
+  main_thread_tdata = create_tdata ();
+  g_assert (main_thread_tdata != NULL);
+  main_thread = gsl_thread_self ();
+  global_thread_list = gsl_ring_prepend (global_thread_list, main_thread);
+  _gsl_init_signal ();
+  _gsl_init_fd_pool ();
+  _gsl_init_data_caches ();
+  _gsl_init_engine_utils ();
+  _gsl_init_loader_gslwave ();
+  _gsl_init_loader_wav ();
+  _gsl_init_loader_oggvorbis ();
+  _gsl_init_loader_mad ();
+}
diff --git a/flow/gsl/gslcommon.h b/flow/gsl/gslcommon.h
new file mode 100644
index 0000000..6b74c77
--- /dev/null
+++ b/flow/gsl/gslcommon.h
@@ -0,0 +1,293 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_COMMON_H__
+#define __GSL_COMMON_H__
+
+#include <gsl/gsldefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+/* --- global initialization --- */
+typedef struct
+{
+  const char *value_name;
+  double      value;
+} GslConfigValue;
+typedef struct
+{
+  guint  n_processors;
+  /* # values to pad around wave chunk blocks per channel */
+  guint  wave_chunk_padding;
+  guint  wave_chunk_big_pad;
+  /* data (file) cache block size (aligned to power of 2) */
+  guint	 dcache_block_size;
+  /* amount of bytes to spare for memory cache */
+  guint  dcache_cache_memory;
+  guint  midi_kammer_note;
+  /* kammer frequency, normally 440Hz, historically 435Hz */
+  gfloat kammer_freq;
+} GslConfig;
+typedef struct _GslMutexTable GslMutexTable;
+void			gsl_init	(const GslConfigValue	values[],
+					 GslMutexTable	       *mtable);
+const GslConfig*	gsl_get_config	(void) G_GNUC_CONST;
+#define	GSL_CONFIG(value)	((gsl_get_config () [0]) . value)
+
+
+/* --- memory allocation --- */
+#define gsl_new_struct(type, n)		((type*) gsl_alloc_memblock (sizeof (type) * (n)))
+#define gsl_new_struct0(type, n)	((type*) gsl_alloc_memblock0 (sizeof (type) * (n)))
+#define gsl_delete_struct(type, mem)	gsl_delete_structs (type, 1, (mem))
+#ifndef	__GNUC__
+#  define gsl_delete_structs(type, n, mem)	(gsl_free_memblock (sizeof (type) * (n), (mem)))
+#else					/* provide typesafety if possible */
+#  define gsl_delete_structs(type, n, mem)	do { \
+  type *__typed_pointer = (mem); \
+  gsl_free_memblock (sizeof (type) * (n), __typed_pointer); \
+} while(0)
+#endif
+#define	GSL_ALIGNED_SIZE(size,align)	((align) > 0 ? _GSL_INTERN_ALIGN (((gsize) (size)), ((gsize) (align))) : (gsize) (size))
+#define	_GSL_INTERN_ALIGN(s, a)		(((s + (a - 1)) / a) * a)
+#define	GSL_STD_ALIGN			(MAX (MAX (sizeof (float), sizeof (int)), sizeof (void*)))
+
+
+/* --- ring (circular-list) --- */
+struct _GslRing
+{
+  GslRing  *next;
+  GslRing  *prev;
+  gpointer  data;
+};
+GslRing*	gsl_ring_prepend	(GslRing	*head,
+					 gpointer	 data);
+GslRing*	gsl_ring_prepend_uniq	(GslRing	*head,
+					 gpointer	 data);
+GslRing*	gsl_ring_append		(GslRing	*head,
+					 gpointer	 data);
+GslRing*	gsl_ring_insert_sorted	(GslRing	*head,
+					 gpointer	 data,
+					 GCompareFunc	 func);
+GslRing*	gsl_ring_remove_node	(GslRing	*head,
+					 GslRing	*node);
+GslRing*	gsl_ring_remove		(GslRing	*head,
+					 gpointer	 data);
+guint		gsl_ring_length		(GslRing	*head);
+GslRing*	gsl_ring_concat		(GslRing	*head1,
+					 GslRing	*head2);
+GslRing*	gsl_ring_find		(GslRing	*head,
+					 gconstpointer	 data);
+GslRing*	gsl_ring_nth		(GslRing	*head,
+					 guint           n);
+gpointer	gsl_ring_nth_data	(GslRing	*head,
+					 guint           n);
+gpointer	gsl_ring_pop_head	(GslRing       **head);
+gpointer	gsl_ring_pop_tail	(GslRing       **head);
+#define		gsl_ring_push_head	gsl_ring_prepend
+#define		gsl_ring_push_tail	gsl_ring_append
+void		gsl_ring_free		(GslRing	*head);
+#define gsl_ring_walk(head,node)	((node) != (head)->prev ? (node)->next : NULL)
+
+
+/* --- GslMessage and debugging --- */
+typedef enum /*< skip >*/
+{
+  GSL_MSG_NOTIFY	= 1 << 0,
+  GSL_MSG_DATA_CACHE	= 1 << 1,
+  GSL_MSG_DATA_HANDLE	= 1 << 2,
+  GSL_MSG_LOADER	= 1 << 3,
+  GSL_MSG_OSC		= 1 << 4,
+  GSL_MSG_ENGINE	= 1 << 5,
+  GSL_MSG_JOBS		= 1 << 6,
+  GSL_MSG_FJOBS		= 1 << 7,
+  GSL_MSG_SCHED		= 1 << 8,
+  GSL_MSG_MASTER	= 1 << 9,
+  GSL_MSG_SLAVE		= 1 << 10
+} GslDebugFlags;
+extern const GDebugKey *gsl_debug_keys;
+extern const guint      gsl_n_debug_keys;
+void		gsl_debug		(GslDebugFlags  reporter,
+					 const gchar   *section,
+					 const gchar   *format,
+					 ...)	G_GNUC_PRINTF (3, 4);
+void		gsl_debug_enable	(GslDebugFlags	dbg_flags);
+void		gsl_debug_disable	(GslDebugFlags	dbg_flags);
+gboolean	gsl_debug_check		(GslDebugFlags	dbg_flags);
+void		gsl_message_send	(GslDebugFlags  reporter,
+					 const gchar   *section,  /* maybe NULL */
+					 GslErrorType	error,	  /* maybe 0 */
+					 const gchar   *messagef,
+					 ...)	G_GNUC_PRINTF (4, 5);
+const gchar*	gsl_strerror		(GslErrorType	error);
+
+/* provide message/debugging macro templates, so custom messages
+ * are done as:
+ * #define FOO_DEBUG	GSL_DEBUG_FUNCTION (GSL_MSG_LOADER, "FOO")
+ * FOO_DEBUG ("some debug message and number: %d", 5);
+ */
+#define GSL_DEBUG_FUNCTION(reporter, section)	_GSL_DEBUG_MACRO_IMPL((reporter), (section))
+#define GSL_MESSAGE_FUNCTION(reporter, section)	_GSL_MESSAGE_MACRO_IMPL((reporter), (section))
+
+
+/* --- GslThread --- */
+typedef void (*GslThreadFunc)		(gpointer	user_data);
+GslThread*	gsl_thread_new		(GslThreadFunc	func,
+					 gpointer	user_data);
+guint		gsl_threads_get_count	(void);
+GslThread*	gsl_thread_self		(void);
+GslThread*	gsl_thread_main		(void);
+
+
+/* --- tick stamps --- */
+typedef struct {
+  guint64 tick_stamp;
+  guint64 system_time;
+} GslTickStampUpdate;
+guint64		   gsl_tick_stamp	(void);
+guint64		   gsl_time_system	(void);
+GslTickStampUpdate gsl_tick_stamp_last	(void);
+#define		   GSL_TICK_STAMP	(_GSL_TICK_STAMP_VAL ())
+#define		   GSL_MAX_TICK_STAMP	(G_MAXUINT64)
+
+
+/* --- thread syncronization --- */
+gboolean	gsl_thread_sleep	(glong		 max_msec);
+gboolean	gsl_thread_aborted	(void);
+void		gsl_thread_queue_abort	(GslThread	*thread);
+void		gsl_thread_abort	(GslThread	*thread);
+void		gsl_thread_wakeup	(GslThread	*thread);
+void		gsl_thread_awake_after	(guint64	 tick_stamp);
+void		gsl_thread_awake_before	(guint64	 tick_stamp);
+void		gsl_thread_get_pollfd	(GPollFD	*pfd);
+
+
+/* --- GslMutex --- */
+#define	gsl_mutex_init(mutex)		(gsl_mutex_table.mutex_init (mutex))
+#define GSL_SPIN_LOCK(mutex)		(gsl_mutex_table.mutex_lock (mutex))
+#define GSL_SPIN_UNLOCK(mutex)		(gsl_mutex_table.mutex_unlock (mutex))
+#define GSL_SYNC_LOCK(mutex)		(gsl_mutex_table.mutex_lock (mutex))
+#define GSL_SYNC_UNLOCK(mutex)		(gsl_mutex_table.mutex_unlock (mutex))
+#define	gsl_mutex_trylock(mutex)	(!gsl_mutex_table.mutex_trylock (mutex))
+#define	gsl_mutex_destroy(mutex)	(gsl_mutex_table.mutex_destroy (mutex))
+#define	gsl_rec_mutex_init(rmutex)	(gsl_mutex_table.rec_mutex_init (rmutex))
+#define	gsl_rec_mutex_lock(rmutex)	(gsl_mutex_table.rec_mutex_lock (rmutex))
+#define	gsl_rec_mutex_unlock(rmutex)	(gsl_mutex_table.rec_mutex_unlock (rmutex))
+#define	gsl_rec_mutex_trylock(rmutex)	(!gsl_mutex_table.rec_mutex_trylock (rmutex))
+#define	gsl_rec_mutex_destroy(rmutex)	(gsl_mutex_table.rec_mutex_destroy (rmutex))
+#define	gsl_cond_init(cond)		(gsl_mutex_table.cond_init (cond))
+#define	gsl_cond_signal(cond)		(gsl_mutex_table.cond_signal (cond))
+#define	gsl_cond_broadcast(cond)	(gsl_mutex_table.cond_broadcast (cond))
+#define	gsl_cond_wait(cond, mutex)	(gsl_mutex_table.cond_wait ((cond), (mutex)))
+#define	gsl_cond_destroy(cond)		(gsl_mutex_table.cond_destroy (cond))
+void	gsl_cond_wait_timed		(GslCond  *cond,
+					 GslMutex *mutex,
+					 glong     max_useconds);
+struct _GslMutexTable
+{
+  void	(*mutex_init)		(GslMutex	*mutex);
+  void	(*mutex_lock)		(GslMutex	*mutex);
+  int	(*mutex_trylock)	(GslMutex	*mutex); /* 0==has_lock */
+  void	(*mutex_unlock)		(GslMutex	*mutex);
+  void	(*mutex_destroy)	(GslMutex	*mutex);
+  void	(*rec_mutex_init)	(GslRecMutex	*mutex);
+  void	(*rec_mutex_lock)	(GslRecMutex	*mutex);
+  int	(*rec_mutex_trylock)	(GslRecMutex	*mutex); /* 0==has_lock */
+  void	(*rec_mutex_unlock)	(GslRecMutex	*mutex);
+  void	(*rec_mutex_destroy)	(GslRecMutex	*mutex);
+  void	(*cond_init)		(GslCond	*cond);
+  void	(*cond_signal)		(GslCond	*cond);
+  void	(*cond_broadcast)	(GslCond	*cond);
+  void	(*cond_wait)		(GslCond	*cond,
+				 GslMutex	*mutex);
+  void	(*cond_wait_timed)	(GslCond	*cond,
+				 GslMutex	*mutex,
+				 gulong		 abs_secs,
+				 gulong		 abs_usecs);
+  void	(*cond_destroy)		(GslCond	*cond);
+};
+
+
+/* --- misc --- */
+const gchar* gsl_byte_order_to_string   (guint           byte_order);
+guint        gsl_byte_order_from_string (const gchar    *string);
+GslErrorType gsl_error_from_errno	(gint		 sys_errno,
+					 GslErrorType	 fallback);
+GslErrorType gsl_check_file		(const gchar	*file_name,
+					 const gchar	*mode);
+
+
+/* --- implementation details --- */
+gpointer	gsl_alloc_memblock	(gsize		 size);
+gpointer	gsl_alloc_memblock0	(gsize		 size);
+void		gsl_free_memblock	(gsize		 size,
+					 gpointer	 memblock);
+void		gsl_alloc_report	(void);
+const guint	gsl_alloc_upper_power2	(const gulong	 number);
+void	       _gsl_tick_stamp_inc	(void);
+void	       _gsl_tick_stamp_set_leap (guint		 ticks);
+void	_gsl_init_signal		(void);
+void	_gsl_init_fd_pool		(void);
+void	_gsl_init_data_caches		(void);
+void	_gsl_init_engine_utils		(void);
+void	_gsl_init_loader_gslwave	(void);
+void	_gsl_init_loader_wav		(void);
+void	_gsl_init_loader_oggvorbis	(void);
+void	_gsl_init_loader_mad		(void);
+#define		GSL_N_IO_RETRIES	(5)
+#define		_GSL_TICK_STAMP_VAL()	(gsl_externvar_tick_stamp + 0)
+extern volatile guint64	gsl_externvar_tick_stamp;
+extern GslMutexTable gsl_mutex_table;
+
+/* we need to provide a REPORTER and SECTION string for the debugging
+ * and message generation functions. for GCC, we also want to make use
+ * of printf style format checking with G_GNUC_PRINTF(). for the non GCC
+ * case, we push REPORTER and SECTION as thread specific data before
+ * invoking the debugging/message generation function. for the GCC case
+ * we use GNUC varargs. (using ISO varargs wouldn't provide any benefit,
+ * for one, ISO vararg support is broken with gcc-2.95 and ansi/c++, and
+ * we only need the macro magic for GCC in the first place to make use
+ * of G_GNUC_PRINTF()).
+ */
+#if     __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
+#define _GSL_DEBUG_MACRO_IMPL(reporter, section)	gsl_debug ((reporter), (section), _GSL_DEBUG_GCCTAIL
+#define _GSL_DEBUG_GCCTAIL(GCCARGS...)			GCCARGS )
+#define _GSL_MESSAGE_MACRO_IMPL(reporter, section)	gsl_message_send ((reporter), (section), _GSL_MESSGAE_GCCTAIL
+#define _GSL_MESSGAE_GCCTAIL(GCCARGS...)		GCCARGS )
+#else   /* non GCC, push data and invoke function */
+#define _GSL_DEBUG_MACRO_IMPL(reporter, section)	(gsl_auxlog_push ((reporter), (section)), gsl_auxlog_debug)
+#define _GSL_MESSAGE_MACRO_IMPL(reporter, section)	(gsl_auxlog_push ((reporter), (section)), gsl_auxlog_message)
+#endif
+/* non-GCC message helpers */
+void		gsl_auxlog_push		(GslDebugFlags   reporter,
+					 const gchar	*section);
+void		gsl_auxlog_debug	(const gchar	*format,
+					 ...);
+void		gsl_auxlog_message	(GslErrorType	 error,
+					 const gchar	*format,
+					 ...);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_COMMON_H__ */
diff --git a/flow/gsl/gslconfig.h.in b/flow/gsl/gslconfig.h.in
new file mode 100644
index 0000000..6e91bd5
--- /dev/null
+++ b/flow/gsl/gslconfig.h.in
@@ -0,0 +1,11 @@
+#define GSL_SIZEOF_PTH_MUTEX_T		(@GSL_SIZEOF_PTH_MUTEX_T@)
+#define GSL_SIZEOF_PTH_COND_T		(@GSL_SIZEOF_PTH_COND_T@)
+#define GSL_HAVE_MUTEXATTR_SETTYPE	(@GSL_HAVE_MUTEXATTR_SETTYPE@ && \
+					GSL_SIZEOF_PTH_MUTEX_T && \
+					GSL_SIZEOF_PTH_COND_T)
+#define GSL_SIZEOF_STD_INTMAX_T		(@GSL_SIZEOF_STD_INTMAX_T@)
+#define GSL_HAVE_LIBMAD			(@GSL_HAVE_LIBMAD@)
+#define GSL_HAVE_OGGVORBIS		(@GSL_HAVE_OGGVORBIS@)
+#define GSL_HAVE_OGGVORBIS_RC3		(@GSL_HAVE_OGGVORBIS_RC3@)
+#define GSL_USE_GSL_GLIB		(@GSL_USE_GSL_GLIB@)
+#define GSL_USE_ARTS_THREADS		(@GSL_USE_ARTS_THREADS@)
diff --git a/flow/gsl/gslconvert.c b/flow/gsl/gslconvert.c
new file mode 100644
index 0000000..95db568
--- /dev/null
+++ b/flow/gsl/gslconvert.c
@@ -0,0 +1,57 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslconvert.h"
+#include <string.h>
+
+
+
+/* --- functions --- */
+gchar*
+gsl_convert_from_utf8 (const gchar *codeset,
+		       const gchar *string)
+{
+  gchar *result;
+
+  g_return_val_if_fail (codeset != NULL, NULL);
+  if (!string)
+    return NULL;
+
+  result = g_convert (string, strlen (string), codeset, GSL_CODESET_UTF8, NULL, NULL, NULL);
+  if (!result)
+    result = g_strconcat ("??unknown-codeset:", codeset, "??", NULL);
+
+  return result;
+}
+
+gchar*
+gsl_convert_to_utf8 (const gchar *codeset,
+		     const gchar *string)
+{
+  gchar *result;
+
+  g_return_val_if_fail (codeset != NULL, NULL);
+  if (!string)
+    return NULL;
+
+  result = g_convert (string, strlen (string), GSL_CODESET_UTF8, codeset, NULL, NULL, NULL);
+  if (!result)
+    result = g_strconcat ("??unknown-codeset:", codeset, "??", NULL);
+
+  return result;
+}
diff --git a/flow/gsl/gslconvert.h b/flow/gsl/gslconvert.h
new file mode 100644
index 0000000..10e685f
--- /dev/null
+++ b/flow/gsl/gslconvert.h
@@ -0,0 +1,43 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_CONVERT_H__
+#define __GSL_CONVERT_H__
+
+#include <gsl/gsldefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GSL_CODESET_8859_1      "ISO-8859-1"	/* LATIN-1 */
+#define GSL_CODESET_UTF8        "UTF8"		/* "ISO-10646" */
+
+gchar*	gsl_convert_from_utf8	(const gchar	*codeset,
+				 const gchar	*string);
+gchar*	gsl_convert_to_utf8	(const gchar	*codeset,
+				 const gchar	*string);
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_CONVERT_H__ */
diff --git a/flow/gsl/gsldatacache.c b/flow/gsl/gsldatacache.c
new file mode 100644
index 0000000..c1df215
--- /dev/null
+++ b/flow/gsl/gsldatacache.c
@@ -0,0 +1,633 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik
+ * Copyright (C) 2004 Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsldatacache.h"
+
+#include "gslcommon.h"
+#include "gsldatahandle.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <time.h>
+
+
+/* --- macros --- */
+#define	NODEP_INDEX(dcache, node_p)	((node_p) - (dcache)->nodes)
+#define	UPPER_POWER2(n)			(gsl_alloc_upper_power2 (MAX (n, 4)))
+#define	CONFIG_NODE_SIZE()		(gsl_get_config ()->dcache_block_size)
+#define AGE_EPSILON                     (3)     /* must be < smallest sweep */
+#define LOW_PERSISTENCY_SWEEP           (5)
+
+/* we use one global lock to protect the dcache list, the list
+ * count (length) and the number of aged (unused) nodes.
+ * also, each dcache has its own mutext to protect updates in
+ * the reference count, nodes or node data blocks.
+ * in order to avoid deadlocks, if both locks need
+ * to be held, they always have to be acquired in the order
+ * 1) global lock, 2) dcache lock.
+ * asyncronous data block filling for a new node occours without
+ * the dcache lock being held (as most calls to GslDataHandle
+ * functions).
+ * however, assignment of the newly acquired data is again
+ * protected by the dcache lock. concurrent API entries
+ * which require demand loading of such data will wait on
+ * a global condition which is always signaled once a new data
+ * block read has been completed. using one global condition
+ * is considered sufficient until shown otherwise by further
+ * profiling/debugging measures.
+ */
+
+
+/* --- prototypes --- */
+static void			dcache_free		(GslDataCache	  *dcache);
+static GslDataCacheNode*	data_cache_new_node_L	(GslDataCache	  *dcache,
+							 gsize		   offset,
+							 guint		   pos,
+							 gboolean	   demand_load);
+
+
+/* --- variables --- */
+static GslMutex	   global_dcache_mutex = { 0, };
+static GslCond	   global_dcache_cond_node_filled = { 0, };
+static GslRing	  *global_dcache_list = NULL;
+static guint	   global_dcache_count = 0;
+static guint       global_dcache_n_aged_nodes = 0;
+
+
+/* --- functions --- */
+void
+_gsl_init_data_caches (void)
+{
+  static gboolean initialized = FALSE;
+
+  g_assert (initialized == FALSE);
+  initialized++;
+
+  g_assert (AGE_EPSILON < LOW_PERSISTENCY_SWEEP);
+  gsl_cond_init (&global_dcache_cond_node_filled);
+  gsl_mutex_init (&global_dcache_mutex);
+}
+
+GslDataCache*
+gsl_data_cache_new (GslDataHandle *dhandle,
+		    guint	   padding)
+{
+  guint node_size = CONFIG_NODE_SIZE () / sizeof (GslDataType);
+  GslDataCache *dcache;
+
+  g_return_val_if_fail (dhandle != NULL, NULL);
+  g_return_val_if_fail (padding > 0, NULL);
+  g_return_val_if_fail (dhandle->name != NULL, NULL);
+  g_assert (node_size == gsl_alloc_upper_power2 (node_size));
+  g_return_val_if_fail (padding < node_size / 2, NULL);
+
+  /* allocate new closed dcache if necessary */
+  dcache = gsl_new_struct (GslDataCache, 1);
+  dcache->dhandle = gsl_data_handle_ref (dhandle);
+  dcache->open_count = 0;
+  gsl_mutex_init (&dcache->mutex);
+  dcache->ref_count = 1;
+  dcache->node_size = node_size;
+  dcache->padding = padding;
+  dcache->max_age = 0;
+  dcache->low_persistency = FALSE; /* FIXME: !gsl_data_handle_needs_cache (dcache->dhandle); */
+  dcache->n_nodes = 0;
+  dcache->nodes = g_renew (GslDataCacheNode*, NULL, UPPER_POWER2 (dcache->n_nodes));
+
+  GSL_SPIN_LOCK (&global_dcache_mutex);
+  global_dcache_list = gsl_ring_append (global_dcache_list, dcache);
+  global_dcache_count++;
+  GSL_SPIN_UNLOCK (&global_dcache_mutex);
+
+  return dcache;
+}
+
+void
+gsl_data_cache_open (GslDataCache *dcache)
+{
+  g_return_if_fail (dcache != NULL);
+  g_return_if_fail (dcache->ref_count > 0);
+
+  GSL_SPIN_LOCK (&dcache->mutex);
+  if (!dcache->open_count)
+    {
+      GslErrorType error;
+
+      error = gsl_data_handle_open (dcache->dhandle);
+      if (error)
+	{
+	  /* FIXME: this is pretty fatal, throw out zero blocks now? */
+	  gsl_message_send (GSL_MSG_DATA_CACHE, "Open",
+			    error,
+			    "failed to open \"%s\": %s",
+			    dcache->dhandle->name,
+			    gsl_strerror (error));
+	}
+      else
+	{
+	  dcache->open_count = 1;
+	  dcache->ref_count++;
+	}
+    }
+  else
+    dcache->open_count++;
+  GSL_SPIN_UNLOCK (&dcache->mutex);
+}
+
+void
+gsl_data_cache_close (GslDataCache *dcache)
+{
+  gboolean need_unref;
+
+  g_return_if_fail (dcache != NULL);
+  g_return_if_fail (dcache->ref_count > 0);
+  g_return_if_fail (dcache->open_count > 0);
+
+  GSL_SPIN_LOCK (&dcache->mutex);
+  dcache->open_count--;
+  need_unref = !dcache->open_count;
+  if (!dcache->open_count)
+    gsl_data_handle_close (dcache->dhandle);
+  GSL_SPIN_UNLOCK (&dcache->mutex);
+  if (need_unref)
+    gsl_data_cache_unref (dcache);
+}
+
+GslDataCache*
+gsl_data_cache_ref (GslDataCache *dcache)
+{
+  g_return_val_if_fail (dcache != NULL, NULL);
+  g_return_val_if_fail (dcache->ref_count > 0, NULL);
+
+  /* we might get invoked with global_dcache_mutex locked */
+  GSL_SPIN_LOCK (&dcache->mutex);
+  dcache->ref_count++;
+  GSL_SPIN_UNLOCK (&dcache->mutex);
+
+  return dcache;
+}
+
+static void
+dcache_free (GslDataCache *dcache)
+{
+  guint i;
+
+  g_return_if_fail (dcache->ref_count == 0);
+  g_return_if_fail (dcache->open_count == 0);
+
+  gsl_data_handle_unref (dcache->dhandle);
+  gsl_mutex_destroy (&dcache->mutex);
+  for (i = 0; i < dcache->n_nodes; i++)
+    {
+      GslDataCacheNode *node = dcache->nodes[i];
+      guint size;
+
+      size = dcache->node_size + (dcache->padding << 1);
+      gsl_delete_structs (GslDataType, size, node->data - dcache->padding);
+      gsl_delete_struct (GslDataCacheNode, node);
+    }
+  g_free (dcache->nodes);
+  gsl_delete_struct (GslDataCache, dcache);
+}
+
+void
+gsl_data_cache_unref (GslDataCache *dcache)
+{
+  g_return_if_fail (dcache != NULL);
+ restart:
+  g_return_if_fail (dcache->ref_count > 0);
+
+  if (dcache->ref_count == 1)	/* possible destruction, need global lock */
+    {
+      g_return_if_fail (dcache->open_count == 0);
+
+      GSL_SPIN_LOCK (&global_dcache_mutex);
+      GSL_SPIN_LOCK (&dcache->mutex);
+      if (dcache->ref_count != 1)
+	{
+	  /* damn, some other thread trapped in, restart */
+	  GSL_SPIN_UNLOCK (&dcache->mutex);
+	  GSL_SPIN_UNLOCK (&global_dcache_mutex);
+	  goto restart;
+	}
+      dcache->ref_count = 0;
+      global_dcache_list = gsl_ring_remove (global_dcache_list, dcache);
+      GSL_SPIN_UNLOCK (&dcache->mutex);
+      global_dcache_count--;
+      global_dcache_n_aged_nodes -= dcache->n_nodes;
+      GSL_SPIN_UNLOCK (&global_dcache_mutex);
+      dcache_free (dcache);
+    }
+  else
+    {
+      GSL_SPIN_LOCK (&dcache->mutex);
+      if (dcache->ref_count < 2)
+	{
+	  /* damn, some other thread trapped in, restart */
+	  GSL_SPIN_UNLOCK (&dcache->mutex);
+	  goto restart;
+	}
+      dcache->ref_count--;
+      GSL_SPIN_UNLOCK (&dcache->mutex);
+    }
+}
+
+static inline GslDataCacheNode**
+data_cache_lookup_nextmost_node_L (GslDataCache *dcache,
+				   gsize         offset)
+{
+  if (dcache->n_nodes > 0)
+    {
+      GslDataCacheNode **check, **nodes = dcache->nodes;
+      guint n_nodes = dcache->n_nodes, node_size = dcache->node_size;
+
+      /* caller has to figure himself whether we return nextmost vs. exact match */
+      nodes -= 1;
+      do
+	{
+	  register gint cmp;
+	  register guint i;
+	  
+	  i = (n_nodes + 1) >> 1;
+	  check = nodes + i;
+	  cmp = offset < (*check)->offset ? -1 : offset >= (*check)->offset + node_size;
+	  if (cmp == 0)
+	    return check;	/* exact match */
+	  else if (cmp > 0)
+	    {
+	      n_nodes -= i;
+	      nodes = check;
+	    }
+	  else /* if (cmp < 0) */
+	    n_nodes = i - 1;
+	}
+      while (n_nodes);
+      
+      return check; /* nextmost */
+    }
+  return NULL;
+}
+
+static inline GslDataCacheNode*
+data_cache_new_node_L (GslDataCache     *dcache,
+		       gsize	         offset,
+		       guint	         pos,
+		       gboolean	         demand_load)
+{
+  GslDataCacheNode **node_p, *dnode;
+  GslDataCacheNode *left_node;
+  GslDataType *data, *node_data;
+  guint new_node_array_size, old_node_array_size = UPPER_POWER2 (dcache->n_nodes);
+  GslLong dhandle_length;
+  guint i, size;
+  gint result;
+
+  i = dcache->n_nodes++;
+  new_node_array_size = UPPER_POWER2 (dcache->n_nodes);
+  if (old_node_array_size != new_node_array_size)
+    dcache->nodes = g_renew (GslDataCacheNode*, dcache->nodes, new_node_array_size);
+  node_p = dcache->nodes + pos;
+  g_memmove (node_p + 1, node_p, (i - pos) * sizeof (*node_p));
+  dnode = gsl_new_struct (GslDataCacheNode, 1);
+  (*node_p) = dnode;
+  dnode->offset = offset & ~(dcache->node_size - 1);
+  dnode->ref_count = 1;
+  dnode->age = 0;
+  dnode->data = NULL;
+  GSL_SPIN_UNLOCK (&dcache->mutex);
+
+  size = dcache->node_size + (dcache->padding << 1);
+  data = gsl_new_struct (GslDataType, size);
+  node_data = data + dcache->padding;
+  offset = dnode->offset;
+  if (dcache->padding > offset)		/* pad out bytes before data start */
+    {
+      guint short_pad = dcache->padding - offset;
+
+      memset (data, 0, short_pad * sizeof (GslDataType));
+      size -= short_pad;
+      data += short_pad;
+      offset -= (dcache->padding - short_pad); /* should always result in offset=0 */
+    }
+  else
+    offset -= dcache->padding;
+  if (!demand_load)
+    g_message (G_STRLOC ":FIXME: lazy data loading not yet supported");
+
+  /* if we have a left node, and it contains data that we need, copy it */
+  left_node = pos ? dcache->nodes[pos - 1] : NULL;
+  if (left_node)
+    {
+      guint left_node_size = dcache->node_size;
+      gint left_node_offset = left_node->offset;
+      GslDataType *left_node_data = left_node->data;
+
+      /* padding around left_node */
+      left_node_size += (dcache->padding << 1);
+      left_node_offset -= dcache->padding;
+      left_node_data -= dcache->padding;
+
+      if (offset < left_node_offset + left_node_size)
+	{
+	  guint left_node_copy = left_node_offset + left_node_size - offset;
+
+	  memcpy (data, left_node_data + offset - left_node_offset,
+	                left_node_copy * sizeof (GslDataType));
+
+	  offset += left_node_copy;
+	  size -= left_node_copy;
+	  data += left_node_copy;
+	}
+    }
+  dhandle_length = gsl_data_handle_length (dcache->dhandle);
+  do
+    {
+      if (offset >= dhandle_length)
+	break;
+      size = MIN (size, dhandle_length - offset);
+      result = gsl_data_handle_read (dcache->dhandle, offset, size, data);
+      if (result < 0)
+	{
+	  gsl_message_send (GSL_MSG_DATA_CACHE, "ReadAhead",
+			    GSL_ERROR_READ_FAILED,
+			    "reading from \"%s\"", dcache->dhandle->name);
+	  break;
+	}
+      else
+	{
+	  offset += result;
+	  size -= result;
+	  data += result;
+	}
+    }
+  while (size && result > 0);
+  memset (data, 0, size * sizeof (data[0]));
+
+  GSL_SPIN_LOCK (&dcache->mutex);
+  dnode->data = node_data;
+  gsl_cond_broadcast (&global_dcache_cond_node_filled);
+  
+  return dnode;
+}
+
+GslDataCacheNode*
+gsl_data_cache_ref_node (GslDataCache       *dcache,
+			 gsize               offset,
+			 GslDataCacheRequest load_request)
+{
+  GslDataCacheNode **node_p, *node;
+  guint insertion_pos;
+
+  g_return_val_if_fail (dcache != NULL, NULL);
+  g_return_val_if_fail (dcache->ref_count > 0, NULL);
+  g_return_val_if_fail (dcache->open_count > 0, NULL);
+  g_return_val_if_fail (offset < gsl_data_handle_length (dcache->dhandle), NULL);
+
+  GSL_SPIN_LOCK (&dcache->mutex);
+  node_p = data_cache_lookup_nextmost_node_L (dcache, offset);
+  if (node_p)
+    {
+      node = *node_p;
+      if (offset >= node->offset && offset < node->offset + dcache->node_size)
+	{
+	  gboolean rejuvenate_node = !node->ref_count;
+
+	  if (load_request == GSL_DATA_CACHE_PEEK)
+	    {
+	      if (node->data)
+		node->ref_count++;
+	      else
+		node = NULL;
+	      GSL_SPIN_UNLOCK (&dcache->mutex);
+              if (node && rejuvenate_node)
+                {
+                  GSL_SPIN_LOCK (&global_dcache_mutex); /* different lock */
+                  global_dcache_n_aged_nodes--;
+                  GSL_SPIN_UNLOCK (&global_dcache_mutex);
+                }
+	      return node;
+	    }
+
+	  node->ref_count++;
+	  if (load_request == GSL_DATA_CACHE_DEMAND_LOAD)
+	    while (!node->data)
+	      gsl_cond_wait (&global_dcache_cond_node_filled, &dcache->mutex);
+	  GSL_SPIN_UNLOCK (&dcache->mutex);
+	  /* g_printerr ("hit: %d :%d: %d\n", node->offset, offset, node->offset + dcache->node_size); */
+
+	  if (rejuvenate_node)
+	    {
+	      GSL_SPIN_LOCK (&global_dcache_mutex); /* different lock */
+	      global_dcache_n_aged_nodes--;
+	      GSL_SPIN_UNLOCK (&global_dcache_mutex);
+	    }
+	  
+	  return node;					/* exact match */
+	}
+      insertion_pos = NODEP_INDEX (dcache, node_p);	/* insert before neighbour */
+      if (offset > node->offset)			/* insert after neighbour */
+	insertion_pos += 1;
+      /* g_printerr ("mis: %d :%d: %d\n", node->offset, offset, node->offset + dcache->node_size); */
+    }
+  else
+    insertion_pos = 0;	/* insert at start */
+
+  if (load_request != GSL_DATA_CACHE_PEEK)
+    node = data_cache_new_node_L (dcache, offset, insertion_pos, load_request == GSL_DATA_CACHE_DEMAND_LOAD);
+  else
+    node = NULL;
+
+  GSL_SPIN_UNLOCK (&dcache->mutex);
+
+  return node;
+}
+
+static gboolean /* still locked */
+data_cache_free_olders_Lunlock (GslDataCache *dcache,
+                                guint         max_lru)  /* how many lru nodes to keep */
+{
+  GslDataCacheNode **slot_p;
+  guint i, rejuvenate, size;
+  guint n_freed = 0;
+
+  g_return_val_if_fail (dcache != NULL, TRUE);
+
+  /* it doesn't make sense to free nodes below the jitter that
+   * AGE_EPSILON attempts to prevent.
+   */
+  max_lru = MAX (AGE_EPSILON, max_lru);
+  if (max_lru >= dcache->max_age)
+    return TRUE;
+
+  rejuvenate = dcache->max_age - max_lru;
+  if (0)
+    g_print ("start sweep: dcache (%p) with %u nodes, max_age: %u, rejuvenate: %u (max_lru: %u)\n",
+	      dcache, dcache->n_nodes, dcache->max_age, rejuvenate, max_lru);
+  size = dcache->node_size + (dcache->padding << 1);
+  slot_p = NULL;
+  for (i = 0; i < dcache->n_nodes; i++)
+    {
+      GslDataCacheNode *node = dcache->nodes[i];
+
+      if (!node->ref_count && node->age <= rejuvenate)
+	{
+	  gsl_delete_structs (GslDataType, size, node->data - dcache->padding);
+	  gsl_delete_struct (GslDataCacheNode, node);
+	  if (!slot_p)
+	    slot_p = dcache->nodes + i;
+	  n_freed++;
+	}
+      else
+	{
+	  node->age -= MIN (rejuvenate, node->age);
+	  if (slot_p)
+	    {
+	      *slot_p = node;
+	      slot_p++;
+	    }
+	}
+    }
+  dcache->max_age = max_lru;
+  if (slot_p)
+    dcache->n_nodes = NODEP_INDEX (dcache, slot_p);
+  GSL_SPIN_UNLOCK (&dcache->mutex);
+
+  if (n_freed)
+    {
+      GSL_SPIN_LOCK (&global_dcache_mutex);
+      global_dcache_n_aged_nodes -= n_freed;
+      GSL_SPIN_UNLOCK (&global_dcache_mutex);
+    }
+
+  if (0)
+    g_printerr ("freed %u nodes (%u bytes) remaining %u bytes\n",
+		n_freed, n_freed * CONFIG_NODE_SIZE (),
+		global_dcache_n_aged_nodes * CONFIG_NODE_SIZE ());
+  return FALSE;
+}
+
+void
+gsl_data_cache_unref_node (GslDataCache     *dcache,
+			   GslDataCacheNode *node)
+{
+  GslDataCacheNode **node_p;
+  gboolean check_cache;
+
+  g_return_if_fail (dcache != NULL);
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (node->ref_count > 0);
+
+  GSL_SPIN_LOCK (&dcache->mutex);
+  node_p = data_cache_lookup_nextmost_node_L (dcache, node->offset);
+  g_assert (node_p && *node_p == node);	/* paranoid check lookup, yeah! */
+  node->ref_count -= 1;
+  check_cache = !node->ref_count;
+  if (!node->ref_count &&
+      (node->age + AGE_EPSILON <= dcache->max_age ||
+       dcache->max_age < AGE_EPSILON))
+    node->age = ++dcache->max_age;
+  GSL_SPIN_UNLOCK (&dcache->mutex);
+
+  if (check_cache)
+    {
+      guint node_size = CONFIG_NODE_SIZE ();
+      guint cache_mem = gsl_get_config ()->dcache_cache_memory;
+      guint current_mem;
+
+      /* FIXME: cache sweeping should not be done from _unref_node for high persistency caches */
+      GSL_SPIN_LOCK (&global_dcache_mutex);
+      global_dcache_n_aged_nodes++;
+      current_mem = node_size * global_dcache_n_aged_nodes;
+      if (current_mem > cache_mem)
+	{
+	  guint dcache_count, needs_unlock;
+	  dcache = gsl_ring_pop_head (&global_dcache_list);
+	  GSL_SPIN_LOCK (&dcache->mutex);
+	  dcache->ref_count++;
+	  global_dcache_list = gsl_ring_append (global_dcache_list, dcache);
+	  dcache_count = global_dcache_count;
+	  GSL_SPIN_UNLOCK (&global_dcache_mutex);
+	  if (dcache->low_persistency)
+	    needs_unlock = data_cache_free_olders_Lunlock (dcache, LOW_PERSISTENCY_SWEEP);
+	  else
+	    {
+	      guint max_lru;
+	      /* try to free the actual cache overflow from the
+	       * dcache we just picked, but don't free more than
+	       * 25% of its nodes yet.
+	       * overflow is actual overhang + ~6% of cache size,
+	       * so cache sweeps are triggered less frequently.
+	       */
+	      current_mem -= cache_mem;		/* overhang */
+	      current_mem += cache_mem >> 4;	/* overflow = overhang + 6% */
+	      current_mem /= node_size;		/* n_nodes to free */
+	      current_mem = MIN (current_mem, dcache->n_nodes);
+	      max_lru = dcache->n_nodes >> 1;
+	      max_lru += max_lru >> 1;		/* 75% of n_nodes */
+	      max_lru = MAX (max_lru, dcache->n_nodes - current_mem);
+	      needs_unlock = data_cache_free_olders_Lunlock (dcache, MAX (max_lru, LOW_PERSISTENCY_SWEEP));
+	    }
+	  if (needs_unlock)
+	    GSL_SPIN_UNLOCK (&dcache->mutex);
+	}
+      else
+	GSL_SPIN_UNLOCK (&global_dcache_mutex);
+    }
+}
+
+void
+gsl_data_cache_free_olders (GslDataCache *dcache,
+			    guint         max_age)
+{
+  gboolean needs_unlock;
+  g_return_if_fail (dcache != NULL);
+
+  GSL_SPIN_LOCK (&dcache->mutex);
+  needs_unlock = data_cache_free_olders_Lunlock (dcache, max_age);
+  if (needs_unlock)
+    GSL_SPIN_UNLOCK (&dcache->mutex);
+}
+
+GslDataCache*
+gsl_data_cache_from_dhandle (GslDataHandle *dhandle,
+			     guint          min_padding)
+{
+  GslRing *ring;
+
+  g_return_val_if_fail (dhandle != NULL, NULL);
+
+  GSL_SPIN_LOCK (&global_dcache_mutex);
+  for (ring = global_dcache_list; ring; ring = gsl_ring_walk (global_dcache_list, ring))
+    {
+      GslDataCache *dcache = ring->data;
+
+      if (dcache->dhandle == dhandle && dcache->padding >= min_padding)
+	{
+	  gsl_data_cache_ref (dcache);
+	  GSL_SPIN_UNLOCK (&global_dcache_mutex);
+	  return dcache;
+	}
+    }
+  GSL_SPIN_UNLOCK (&global_dcache_mutex);
+
+  return gsl_data_cache_new (dhandle, min_padding);
+}
diff --git a/flow/gsl/gsldatacache.h b/flow/gsl/gsldatacache.h
new file mode 100644
index 0000000..5eb3677
--- /dev/null
+++ b/flow/gsl/gsldatacache.h
@@ -0,0 +1,87 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_DATA_CACHE_H__
+#define __GSL_DATA_CACHE_H__
+
+#include <gsl/gslcommon.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- macros --- */
+#define	GSL_DATA_CACHE_NODE_SIZE(dcache)	(((GslDataCache*) (dcache))->node_size)
+
+
+/* --- typedefs & structures --- */
+typedef gfloat                     GslDataType;
+typedef struct _GslDataCacheNode   GslDataCacheNode;
+struct _GslDataCache
+{
+  GslDataHandle	       *dhandle;
+  guint			open_count;
+  GslMutex		mutex;
+  guint			ref_count;
+  guint			node_size;	/* power of 2, const for all dcaches */
+  guint			padding;	/* n_values around blocks */
+  guint			max_age;
+  gboolean		low_persistency;
+  guint			n_nodes;
+  GslDataCacheNode    **nodes;
+};
+struct _GslDataCacheNode
+{
+  gsize		offset;
+  guint		ref_count;
+  guint		age;
+  GslDataType  *data;	/* NULL while busy */
+};
+typedef enum
+{
+  GSL_DATA_CACHE_REQUEST     = FALSE, /* node->data may be NULL and will be filled */
+  GSL_DATA_CACHE_DEMAND_LOAD = TRUE,  /* blocks until node->data != NULL */
+  GSL_DATA_CACHE_PEEK	     = 2      /* may return NULL node, data != NULL otherwise */
+} GslDataCacheRequest;
+
+
+/* --- prototypes --- */
+GslDataCache*	  gsl_data_cache_new		(GslDataHandle	    *dhandle,
+						 guint		     padding);
+GslDataCache*	  gsl_data_cache_ref		(GslDataCache	    *dcache);
+void		  gsl_data_cache_unref		(GslDataCache	    *dcache);
+void		  gsl_data_cache_open		(GslDataCache	    *dcache);
+void		  gsl_data_cache_close		(GslDataCache	    *dcache);
+GslDataCacheNode* gsl_data_cache_ref_node	(GslDataCache	    *dcache,
+						 gsize		     offset,
+						 GslDataCacheRequest load_request);
+void		  gsl_data_cache_unref_node	(GslDataCache	    *dcache,
+						 GslDataCacheNode   *node);
+void		  gsl_data_cache_free_olders	(GslDataCache	    *dcache,
+						 guint		     max_age);
+GslDataCache*	  gsl_data_cache_from_dhandle	(GslDataHandle	    *dhandle,
+						 guint		     min_padding);
+						 
+						 
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_DATA_CACHE_H__ */
diff --git a/flow/gsl/gsldatahandle-lbuffer.c b/flow/gsl/gsldatahandle-lbuffer.c
new file mode 100644
index 0000000..99538bf
--- /dev/null
+++ b/flow/gsl/gsldatahandle-lbuffer.c
@@ -0,0 +1,11 @@
+
+
+typedef struct {
+  GslDataHandle dhandle;
+
+  GslLong pcm_pos;
+  guint	  pcm_length;
+  guint   pcm_size;
+} LBufferHandle;
+
+/* ring buffer, caching the last n values read */
diff --git a/flow/gsl/gsldatahandle-mad.c b/flow/gsl/gsldatahandle-mad.c
new file mode 100644
index 0000000..fcfdd7f
--- /dev/null
+++ b/flow/gsl/gsldatahandle-mad.c
@@ -0,0 +1,711 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include <gsl/gsldatahandle-mad.h>
+
+#include "gslfilehash.h"
+#include <gsl/gsldatautils.h>
+#include <assert.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+
+#if	GSL_HAVE_LIBMAD
+#include <mad.h>
+
+
+/* --- debugging and errors --- */
+#define	MAD_DEBUG		GSL_DEBUG_FUNCTION (GSL_MSG_DATA_HANDLE, "MAD")
+#define	MAD_MSG			GSL_MESSAGE_FUNCTION (GSL_MSG_DATA_HANDLE, "MAD")
+
+
+/* --- defines --- */
+#define	FILE_BUFFER_SIZE	(1024 * 44)	/* approximately 1 second at 320 kbit */
+#define	SEEK_BY_READ_AHEAD(h)	(((h)->sample_rate / ((h)->frame_size * 2))) /* FIXME */
+#define	MAX_CHANNELS		(5)
+
+
+/* --- typedefs & structures --- */
+typedef struct
+{
+  GslDataHandle dhandle;
+
+  /* setup data */
+  guint		sample_rate;
+  guint		frame_size;
+  guint         stream_options;
+  guint         accumulate_state_frames;
+  guint         skip_seek_table : 1;
+
+  /* file IO */
+  guint         eof : 1;
+  GslHFile     *hfile;
+  guint		file_pos;
+  const gchar  *error;
+
+  /* seek table */
+  GTime		seek_mtime;
+  guint		n_seeks;
+  guint	       *seeks;
+
+  /* file read buffer */
+  guint		bfill;
+  guint8        buffer[FILE_BUFFER_SIZE + MAD_BUFFER_GUARD];
+
+  /* pcm housekeeping */
+  GslLong	pcm_pos, pcm_length, next_pcm_pos;
+
+  /* libmad structures */
+  struct mad_stream   stream;
+  struct mad_frame    frame;
+  struct mad_synth    synth;
+} MadHandle;
+
+
+/* --- prototypes --- */
+static GslLong	dh_mad_coarse_seek	(GslDataHandle *data_handle,
+					 GslLong        voffset);
+
+
+/* --- functions --- */
+static gboolean		/* FALSE: handle->eof || errno != 0 */
+stream_read (MadHandle *handle)
+{
+  struct mad_stream *stream = &handle->stream;
+  guint l;
+
+  /* no further data to read (flag must be reset upon seeks) */
+  if (handle->eof)
+    return FALSE;
+
+  /* keep remaining data in buffer */
+  if (stream->next_frame && handle->bfill)
+    {
+      handle->bfill = handle->buffer + handle->bfill - stream->next_frame;
+      memmove (handle->buffer, stream->next_frame, handle->bfill);
+    }
+
+  /* fill buffer */
+  l = gsl_hfile_pread (handle->hfile, handle->file_pos, FILE_BUFFER_SIZE - handle->bfill, handle->buffer + handle->bfill);
+  if (l > 0)
+    {
+      handle->bfill += l;
+      handle->file_pos += l;
+    }
+  else if (l == 0)
+    {
+      handle->eof = TRUE;
+      memset (handle->buffer + handle->bfill, 0, MAD_BUFFER_GUARD);
+      handle->bfill += MAD_BUFFER_GUARD;
+      handle->file_pos += MAD_BUFFER_GUARD;	/* bogus, but doesn't matter at eof */
+    }
+
+  mad_stream_buffer (stream, handle->buffer, handle->bfill);
+
+  return l < 0 ? FALSE : TRUE;
+}
+
+static gboolean
+check_frame_validity (MadHandle         *handle,
+		      struct mad_header *header)
+{
+  guint frame_size = MAD_NSBSAMPLES (header) * 32;
+  gchar *reason = NULL;
+
+  if (frame_size <= 0)
+    reason = "frame_size < 1";
+
+  if (handle->frame_size && handle->dhandle.setup.n_channels)
+    {
+#if 0
+      if (frame_size != handle->frame_size)
+	reason = "frame with non-standard size";
+#endif
+      if (MAD_NCHANNELS (header) != handle->dhandle.setup.n_channels)
+	reason = "frame with non-standard channel count";
+    }
+
+  if (reason)
+    {
+      MAD_DEBUG ("skipping frame: %s", reason);
+      return FALSE;
+    }
+  else
+    return TRUE;
+}
+
+static gboolean
+read_next_frame_header (MadHandle *handle)
+{
+  gboolean succeeded = TRUE;
+
+  /* fetch next frame header */
+  if (mad_header_decode (&handle->frame.header, &handle->stream) < 0)
+    {
+      if (!MAD_RECOVERABLE (handle->stream.error) ||
+	  handle->stream.error == MAD_ERROR_LOSTSYNC)
+	{
+	  /* read on */
+	  if (!stream_read (handle))
+	    {
+	      handle->error = handle->eof ? NULL : g_strerror (errno);
+	      return FALSE;
+	    }
+	  return read_next_frame_header (handle);	/* retry */
+	}
+
+      if (!check_frame_validity (handle, &handle->frame.header))
+	return read_next_frame_header (handle);		/* retry */
+
+      succeeded = FALSE;
+    }
+
+  handle->error = handle->stream.error ? mad_stream_errorstr (&handle->stream) : NULL;
+
+  return succeeded;
+}
+
+static gboolean		/* FALSE: handle->eof || handle->error != NULL */
+pcm_frame_read (MadHandle *handle,
+		gboolean   synth)
+{
+  gboolean succeeded = TRUE;
+
+  if (mad_frame_decode (&handle->frame, &handle->stream) < 0)
+    {
+      if (!MAD_RECOVERABLE (handle->stream.error) ||
+	  handle->stream.error == MAD_ERROR_LOSTSYNC)
+	{
+	  /* MAD_RECOVERABLE()==TRUE:  frame was read, decoding failed (about to skip frame)
+	   * MAD_RECOVERABLE()==FALSE: frame was not read, need data
+	   * note: MAD_RECOVERABLE (MAD_ERROR_LOSTSYNC) == TRUE
+	   */
+
+	  /* read on */
+	  if (!stream_read (handle))
+	    {
+	      handle->error = handle->eof ? NULL : g_strerror (errno);
+	      return FALSE;
+	    }
+	  return pcm_frame_read (handle, synth);	/* retry */
+	}
+
+      succeeded = FALSE;
+      if (synth)
+	mad_frame_mute (&handle->frame);
+    }
+
+  handle->pcm_pos = handle->next_pcm_pos;
+  handle->pcm_length = handle->frame_size;
+  handle->next_pcm_pos += handle->pcm_length;
+
+  if (synth)
+    mad_synth_frame (&handle->synth, &handle->frame);
+
+  handle->error = handle->stream.error && !succeeded ? mad_stream_errorstr (&handle->stream) : NULL;
+
+  return succeeded;
+}
+
+static guint*
+create_seek_table (MadHandle *handle,
+		   guint     *n_seeks_p)
+{
+  guint *seeks = NULL;
+  guint offs, n_seeks = 0;
+
+  *n_seeks_p = 0;
+  mad_synth_finish (&handle->synth);
+  mad_frame_finish (&handle->frame);
+  mad_stream_finish (&handle->stream);
+  mad_stream_init (&handle->stream);
+  mad_frame_init (&handle->frame);
+  mad_synth_init (&handle->synth);
+  mad_stream_options (&handle->stream, handle->stream_options);
+
+  offs = 0;
+  /* lseek (handle->hfile, offs, SEEK_SET) */
+  handle->eof = FALSE;
+  handle->bfill = 0;
+  handle->file_pos = 0;
+
+  do
+    {
+      while (read_next_frame_header (handle))
+	{
+	  guint this_pos = handle->file_pos - handle->bfill + handle->stream.this_frame - handle->buffer;
+	  guint i = n_seeks++;
+	  
+	  if (n_seeks > 256 * 1024)	/* FIXME: max_frames */
+	    {
+	      g_free (seeks);
+	      return NULL;		/* FIXME: ETOOBIG */
+	    }
+	  
+	  if (gsl_alloc_upper_power2 (n_seeks) > gsl_alloc_upper_power2 (i))
+	    seeks = g_renew (guint, seeks, gsl_alloc_upper_power2 (n_seeks));
+	  seeks[i] = this_pos;
+	  
+	  if (0)
+	    {
+	      if (mad_frame_decode (&handle->frame, &handle->stream) < 0)
+		MAD_DEBUG ("seektable frame read failed: %s", mad_stream_errorstr (&handle->stream));
+	      mad_synth_frame (&handle->synth, &handle->frame);
+	      MAD_DEBUG ("frame(%u) PCM:%u => FILE:%u FDIFF:%d (%x %x %x) br:%lu time:%ld/%lu mode:%u ext:%u flags:0x%x phase:%u",
+			 i, i * handle->frame_size, this_pos, this_pos - seeks[MAX (i, 1) - 1],
+			 handle->stream.this_frame[0], handle->stream.this_frame[1],
+			 (handle->stream.this_frame[1] >> 1) & 3,
+			 handle->frame.header.bitrate,
+			 handle->frame.header.duration.seconds,
+			 handle->frame.header.duration.fraction,
+			 handle->frame.header.mode,
+			 handle->frame.header.mode_extension,
+			 handle->frame.header.flags,
+			 handle->synth.phase);
+	    }
+	}
+      
+      if (!handle->eof)
+	{
+	  MAD_DEBUG ("reading seektable frame failed: %s", handle->error ? handle->error : "Unknown");
+	  
+	  /* frame read failed for a reason other than eof */
+	  g_free (seeks);
+	  return NULL;		/* FIXME: EIO/errno */
+	}
+    }
+  while (!handle->eof);
+      
+  /* reset file offset */
+  offs = 0;
+  /* lseek (handle->hfile, offs, SEEK_SET) */
+  handle->eof = FALSE;
+  handle->file_pos = 0;
+  handle->bfill = 0;
+  
+  /* shrink table */
+  seeks = g_renew (guint, seeks, n_seeks);
+  *n_seeks_p = n_seeks;
+
+  return seeks;
+}
+
+static GslErrorType
+dh_mad_open (GslDataHandle      *dhandle,
+	     GslDataHandleSetup *setup)
+{
+  MadHandle *handle = (MadHandle*) dhandle;
+  GslHFile *hfile;
+  GslLong n;
+  gboolean seek_invalidated = FALSE;
+
+  hfile = gsl_hfile_open (handle->dhandle.name);
+  if (!hfile)
+    return gsl_error_from_errno (errno, GSL_ERROR_OPEN_FAILED);
+  handle->hfile = hfile;
+
+  seek_invalidated |= handle->seek_mtime != hfile->mtime;
+  handle->bfill = 0;
+  handle->eof = FALSE;
+  handle->pcm_pos = 0;
+  handle->pcm_length = 0;
+  handle->next_pcm_pos = 0;
+  handle->file_pos = 0;
+  mad_stream_init (&handle->stream);
+  mad_frame_init (&handle->frame);
+  mad_synth_init (&handle->synth);
+  mad_stream_options (&handle->stream, handle->stream_options);
+
+  /* fetch first frame */
+  if (!read_next_frame_header (handle))
+    goto OPEN_FAILED;
+
+  /* get n_channels, frame size and sample rate */
+  setup->bit_depth = 24;
+  setup->n_channels = MAD_NCHANNELS (&handle->frame.header);
+  n = MAD_NSBSAMPLES (&handle->frame.header) * 32;
+  seek_invalidated |= n != handle->frame_size;
+  handle->frame_size = n;
+  handle->sample_rate = handle->frame.header.samplerate;
+  if (setup->n_channels < 1 ||
+      setup->n_channels > MAX_CHANNELS ||
+      handle->frame_size < 1 ||
+      handle->sample_rate < 1)
+    goto OPEN_FAILED;
+  
+  /* seek through the stream to collect frame positions */
+  if (seek_invalidated || !handle->n_seeks)
+    {
+      handle->seek_mtime = hfile->mtime;
+      handle->n_seeks = 0;
+      g_free (handle->seeks);
+      handle->seeks = NULL;
+      if (handle->skip_seek_table)
+	{
+	  /* fake seek table */
+	  handle->n_seeks = 1;
+	  handle->seeks = g_new (guint, handle->n_seeks);
+	  handle->seeks[0] = 0;
+	}
+      else
+	{
+	  handle->seeks = create_seek_table (handle, &handle->n_seeks);
+	  if (!handle->seeks)
+	    goto OPEN_FAILED;
+	  MAD_DEBUG ("frames in seektable: %u", handle->n_seeks);
+	}
+    }
+  
+  /* validate/setup handle length */
+  n = handle->n_seeks * handle->frame_size * setup->n_channels;
+  if (n > 0)
+    setup->n_values = n;
+  else
+    goto OPEN_FAILED;
+
+  if (dh_mad_coarse_seek (&handle->dhandle, 0) != 0)
+    goto OPEN_FAILED;
+
+  return GSL_ERROR_NONE;
+
+ OPEN_FAILED:
+  g_free (handle->seeks);
+  handle->seeks = NULL;
+  handle->n_seeks = 0;
+  handle->seek_mtime = -1;
+  handle->bfill = 0;
+  handle->eof = FALSE;
+  handle->pcm_pos = 0;
+  handle->pcm_length = 0;
+  handle->next_pcm_pos = 0;
+  handle->file_pos = 0;
+  mad_synth_finish (&handle->synth);
+  mad_frame_finish (&handle->frame);
+  mad_stream_finish (&handle->stream);
+  gsl_hfile_close (handle->hfile);
+  handle->hfile = NULL;
+
+  return GSL_ERROR_OPEN_FAILED;
+}
+
+static GslLong
+dh_mad_read (GslDataHandle *dhandle,
+	     GslLong        voffset, /* in values */
+	     GslLong        n_values,
+	     gfloat        *values)
+{
+  MadHandle *handle = (MadHandle*) dhandle;
+  GslLong pos = voffset / dhandle->setup.n_channels;
+  gboolean frame_read_ok = TRUE;
+
+  if (pos < handle->pcm_pos ||
+      pos >= handle->pcm_pos + handle->pcm_length + SEEK_BY_READ_AHEAD (handle) * handle->frame_size)
+    {
+      GslLong tmp;
+
+      /* suckage, need to do lengthy seek in file */
+      tmp = dh_mad_coarse_seek (dhandle, voffset);
+      g_assert (tmp <= voffset);
+    }
+ 
+  while (pos >= handle->pcm_pos + handle->pcm_length)
+    frame_read_ok = pcm_frame_read (handle, TRUE);
+
+  /* check if the last call to pcm_frame_read() failed */
+  if (!frame_read_ok)
+    {
+      if (handle->stream.error == MAD_ERROR_BADDATAPTR)
+	{
+	  /* if we encounter that the inter-frame accumulated layer-III state
+	   * is not complete now, we'll try to increase the amount of frames
+	   * we accumulate
+	   */
+	  if (handle->accumulate_state_frames < 10)
+	    {
+	      handle->accumulate_state_frames++;
+	      MAD_DEBUG ("retrying seek with accumulate_state_frames=%d",
+			 handle->accumulate_state_frames);
+
+	      /* force dh_mad_read to retry the seek */
+	      dh_mad_coarse_seek (dhandle, 0);
+	      return dh_mad_read (dhandle, voffset, n_values, values);
+	    }
+	  else
+	    {
+	      MAD_DEBUG ("synthesizing frame failed, accumulate_state_frames is already %u: %s",
+			 handle->accumulate_state_frames, handle->error);
+	      return -1;
+	    }
+	}
+      else
+	{
+	  MAD_DEBUG ("failed to synthesize frame: %s", handle->error);
+	  return -1;
+	}
+    }
+
+  n_values = MIN (n_values, handle->pcm_length * dhandle->setup.n_channels);
+
+  /* interleave into output buffer */
+  if (pos >= handle->pcm_pos && pos < handle->pcm_pos + handle->pcm_length)
+    {
+      guint offset = voffset - handle->pcm_pos * dhandle->setup.n_channels;
+      guint align = offset % dhandle->setup.n_channels;
+      guint n_samples = MIN (n_values, handle->pcm_length * dhandle->setup.n_channels - offset);
+      mad_fixed_t *pcm[MAX_CHANNELS];
+      gfloat *bound = values + n_samples;
+      guint i;
+
+      offset /= dhandle->setup.n_channels;
+      for (i = 0; i < dhandle->setup.n_channels; i++)
+	pcm[i] = handle->synth.pcm.samples[i] + offset + (i < align);
+      
+      for (i = align; values < bound; values++)
+	{
+	  mad_fixed_t mf = *(pcm[i]++);
+
+	  *values = CLAMP (mf, -MAD_F_ONE, MAD_F_ONE) * (1. / (double) MAD_F_ONE);
+	  if (++i >= dhandle->setup.n_channels)
+	    i = 0;
+	}
+      return n_samples;
+    }
+  else /* something went wrong here, _badly_ */
+    {
+      MAD_MSG (GSL_ERROR_READ_FAILED,
+	       "pcm position screwed (pos: %lu, handle-pos: %lu), aborting read",
+	       pos, handle->pcm_pos);	
+      return -1;
+    }
+}
+
+static GslLong
+dh_mad_coarse_seek (GslDataHandle *dhandle,
+		    GslLong        voffset)
+{
+  MadHandle *handle = (MadHandle*) dhandle;
+  GslLong opos = handle->pcm_pos, pos = voffset / dhandle->setup.n_channels;
+
+  if (voffset < 0)	/* pcm_tell() */
+    return handle->pcm_pos * dhandle->setup.n_channels;
+
+  if (pos < handle->pcm_pos ||
+      pos >= handle->pcm_pos + handle->pcm_length + SEEK_BY_READ_AHEAD (handle))
+    {
+      GslLong offs = pos;
+      guint i, file_pos;
+
+      /* reset decoder state */
+      mad_synth_finish (&handle->synth);
+      mad_frame_finish (&handle->frame);
+      mad_stream_finish (&handle->stream);
+      mad_stream_init (&handle->stream);
+      mad_frame_init (&handle->frame);
+      mad_synth_init (&handle->synth);
+      mad_stream_options (&handle->stream, handle->stream_options);
+
+      /* seek to some frames read ahead to accumulate layer III IDCMT state */
+      offs -= (gint) (handle->frame_size * handle->accumulate_state_frames);
+      offs = CLAMP (offs, 0, (gint) (handle->n_seeks * handle->frame_size));
+
+      /* get file position from seek table */
+      i = offs / handle->frame_size;
+      file_pos = handle->seeks[i];
+
+      /* perform file seek and adjust positions */
+      /* lseek (handle->hfile, file_pos, SEEK_SET) */
+      handle->eof = FALSE;
+      handle->bfill = 0;
+      handle->file_pos = file_pos;
+      handle->pcm_pos = i * handle->frame_size;
+      handle->pcm_length = 0;
+      handle->next_pcm_pos = handle->pcm_pos;
+
+#if 0
+      /* adapt synth phase */
+      handle->synth.phase = ((i + 1) * (handle->frame_size / 32)) % 16;
+#endif
+
+      /* accumulate state */
+      if (pos >= handle->accumulate_state_frames * handle->frame_size)
+	{
+	  guint i;
+	  for (i = 0; i < handle->accumulate_state_frames; i++)
+	    {
+	      gboolean synth = i + 1 == handle->accumulate_state_frames;
+
+	      if (!pcm_frame_read (handle, synth) && handle->stream.error != MAD_ERROR_BADDATAPTR)
+		MAD_DEBUG ("COARSE-SEEK: frame read ahead (%u): failed: %s", i, handle->error);
+	    }
+	}
+
+      MAD_DEBUG ("seek-done: at %lu (f:%lu) want %lu (f:%lu) got %lu (f:%lu) diff %ld (diff-requested %ld)",
+		 opos, opos / handle->frame_size,
+		 pos, pos / handle->frame_size,
+		 handle->pcm_pos, handle->pcm_pos / handle->frame_size,
+		 handle->pcm_pos - opos, pos - opos);
+    }
+
+  return handle->pcm_pos * dhandle->setup.n_channels;
+}
+
+static void
+dh_mad_close (GslDataHandle *data_handle)
+{
+  MadHandle *handle = (MadHandle*) data_handle;
+
+  handle->bfill = 0;
+  handle->eof = FALSE;
+  handle->pcm_pos = 0;
+  handle->pcm_length = 0;
+  handle->next_pcm_pos = 0;
+  handle->file_pos = 0;
+  mad_synth_finish (&handle->synth);
+  mad_frame_finish (&handle->frame);
+  mad_stream_finish (&handle->stream);
+  gsl_hfile_close (handle->hfile);
+  handle->hfile = NULL;
+}
+
+static void
+dh_mad_destroy (GslDataHandle *data_handle)
+{
+  MadHandle *handle = (MadHandle*) data_handle;
+
+  g_free (handle->seeks);
+  handle->seeks = NULL;
+  handle->n_seeks = 0;
+  gsl_data_handle_common_free (data_handle);
+  gsl_delete_struct (MadHandle, handle);
+}
+
+static GslDataHandleFuncs dh_mad_vtable = {
+  dh_mad_open,
+  dh_mad_read,
+  dh_mad_close,
+  dh_mad_destroy,
+  dh_mad_coarse_seek,
+};
+
+static GslDataHandle*
+dh_mad_new (const gchar *file_name,
+	    gboolean     skip_seek_keep_open)
+{
+  MadHandle *handle;
+  gboolean success;
+
+  handle = gsl_new_struct0 (MadHandle, 1);
+  success = gsl_data_handle_common_init (&handle->dhandle, file_name);
+  if (success)
+    {
+      GslErrorType error;
+
+      handle->dhandle.vtable = &dh_mad_vtable;
+      handle->sample_rate = 0;
+      handle->frame_size = 0;
+      handle->stream_options = MAD_OPTION_IGNORECRC;
+      handle->accumulate_state_frames = 0;
+      handle->eof = FALSE;
+      handle->hfile = NULL;
+      handle->file_pos = 0;
+      handle->error = NULL;
+      handle->n_seeks = 0;
+      handle->seeks = NULL;
+      handle->seek_mtime = -1;
+      handle->bfill = 0;
+      handle->pcm_pos = handle->pcm_length = handle->next_pcm_pos = 0;
+
+      /* we can only check matters upon opening
+       */
+      handle->skip_seek_table = skip_seek_keep_open != FALSE;
+      error = gsl_data_handle_open (&handle->dhandle);
+      if (!error)
+	{
+	  if (!skip_seek_keep_open)
+	    gsl_data_handle_close (&handle->dhandle);
+	  return &handle->dhandle;
+	}
+      gsl_data_handle_unref (&handle->dhandle);
+      return NULL;
+    }
+  else
+    {
+      g_free (handle->seeks);
+      gsl_delete_struct (MadHandle, handle);
+      return NULL;
+    }
+}
+
+GslDataHandle*
+gsl_data_handle_new_mad (const gchar *file_name)
+{
+  g_return_val_if_fail (file_name != NULL, NULL);
+
+  return dh_mad_new (file_name, FALSE);
+}
+
+GslErrorType
+gsl_data_handle_mad_testopen (const gchar *file_name,
+			      guint       *n_channels,
+			      gfloat      *mix_freq)
+{
+  GslDataHandle *dhandle;
+  MadHandle *handle;
+  
+  g_return_val_if_fail (file_name != NULL, GSL_ERROR_INTERNAL);
+
+  dhandle = dh_mad_new (file_name, TRUE);
+  if (!dhandle)
+    return GSL_ERROR_OPEN_FAILED;
+
+  handle = (MadHandle*) dhandle;
+  if (n_channels)
+    *n_channels = handle->dhandle.setup.n_channels;
+  if (mix_freq)
+    *mix_freq = handle->sample_rate;
+  gsl_data_handle_close (dhandle);
+  gsl_data_handle_unref (dhandle);
+
+  return GSL_ERROR_NONE;
+}
+
+#else	/* !GSL_HAVE_LIBMAD */
+
+GslDataHandle*
+gsl_data_handle_new_mad (const gchar *file_name)
+{
+  return NULL;
+}
+
+GslErrorType
+gsl_data_handle_mad_testopen (const gchar *file_name,
+			      guint       *n_channels,
+			      gfloat      *mix_freq)
+{
+  return GSL_ERROR_FORMAT_UNKNOWN;
+}
+
+#endif	/* !GSL_HAVE_LIBMAD */
+
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gsldatahandle-mad.h b/flow/gsl/gsldatahandle-mad.h
new file mode 100644
index 0000000..8c73ef7
--- /dev/null
+++ b/flow/gsl/gsldatahandle-mad.h
@@ -0,0 +1,42 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_DATA_HANDLE_MAD_H__
+#define __GSL_DATA_HANDLE_MAD_H__
+
+#include <gsl/gslcommon.h>
+#include <gsl/gsldatahandle.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* linear-read handle. needs buffering handle wrapper
+ */
+GslDataHandle*	gsl_data_handle_new_mad		(const gchar *file_name);
+GslErrorType	gsl_data_handle_mad_testopen	(const gchar *file_name,
+						 guint       *n_channels,
+						 gfloat      *mix_freq);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_DATA_HANDLE_MAD_H__ */
diff --git a/flow/gsl/gsldatahandle-vorbis.c b/flow/gsl/gsldatahandle-vorbis.c
new file mode 100644
index 0000000..9b84ae0
--- /dev/null
+++ b/flow/gsl/gsldatahandle-vorbis.c
@@ -0,0 +1,376 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsldatahandle-vorbis.h"
+
+#if GSL_HAVE_OGGVORBIS
+#include "gslfilehash.h"
+#include <ogg/ogg.h>
+#include <vorbis/vorbisfile.h>
+#include <errno.h>
+
+
+/* --- defines --- */
+#define	MAX_CHANNELS			(16)		/* hard limit, eases our life somewhat */
+/* number of values to decode and throw away instead of seeking. since
+ * seeking can be quite time consuming, this should cover a good range
+ * of seek-ahead space
+ */
+#define	SEEK_BY_READ_AHEAD(vhandle)	(vhandle->max_block_size * 8)
+
+
+/* --- structure --- */
+typedef struct {
+  GslDataHandle dhandle;
+
+  guint    stream;
+  guint    n_streams;
+
+  /* live data */
+  gint64  soffset;	/* our PCM start offset */
+  guint   max_block_size;
+
+  /* pcm read out cache */
+  GslLong pcm_pos, pcm_length;
+  gfloat *pcm[MAX_CHANNELS];
+
+  OggVorbis_File ofile;
+} VorbisHandle;
+
+
+/* --- functions --- */
+static GslErrorType
+ov_errno_to_error (gint         ov_errno,
+		   GslErrorType fallback)
+{
+  switch (ov_errno)
+    {
+    case OV_EOF:	return GSL_ERROR_EOF;
+    case OV_EBADLINK:
+    case OV_EBADPACKET:
+    case OV_HOLE:	return GSL_ERROR_DATA_CORRUPT;
+    case OV_EREAD:	return GSL_ERROR_READ_FAILED;
+    case OV_ENOSEEK:	return GSL_ERROR_SEEK_FAILED;
+    case OV_EFAULT:
+    case OV_EIMPL:	return GSL_ERROR_CODEC_FAILURE;
+    case OV_EINVAL:	return GSL_ERROR_INTERNAL;
+    case OV_ENOTAUDIO:
+    case OV_EVERSION:
+    case OV_EBADHEADER:
+    case OV_ENOTVORBIS:	return GSL_ERROR_FORMAT_INVALID;
+    case OV_FALSE:
+    default:		return fallback;
+    }
+}
+
+static size_t
+rfile_read (void  *ptr,
+	    size_t size,
+	    size_t nmemb,
+	    void  *datasource)
+{
+  GslRFile *rfile = datasource;
+  return gsl_rfile_read (rfile, size * nmemb, ptr);
+}
+
+static int
+rfile_seek (void       *datasource,
+	    ogg_int64_t offset,
+	    int         whence)
+{
+  GslRFile *rfile = datasource;
+  GslLong l;
+  switch (whence)
+    {
+    default:
+    case SEEK_SET:
+      l = gsl_rfile_seek_set (rfile, offset);
+      break;
+    case SEEK_CUR:
+      l = gsl_rfile_position (rfile);
+      l = gsl_rfile_seek_set (rfile, l + offset);
+      break;
+    case SEEK_END:
+      l = gsl_rfile_length (rfile);
+      l = gsl_rfile_seek_set (rfile, l + offset);
+      break;
+    }
+  return l;
+}
+
+static int
+rfile_close (void *datasource)
+{
+  GslRFile *rfile = datasource;
+  gsl_rfile_close (rfile);
+  return 0;
+}
+
+static long
+rfile_tell (void *datasource)
+{
+  GslRFile *rfile = datasource;
+  return gsl_rfile_position (rfile);
+}
+
+static ov_callbacks rfile_ov_callbacks = {
+  rfile_read,
+  rfile_seek,
+  rfile_close,
+  rfile_tell,
+};
+
+static GslErrorType
+dh_vorbis_open (GslDataHandle      *data_handle,
+		GslDataHandleSetup *setup)
+{
+  VorbisHandle *vhandle = (VorbisHandle*) data_handle;
+  GslRFile *rfile;
+  vorbis_info *vi;
+  GslLong n, i;
+  gint err;
+  
+#if 0
+  file = fopen (vhandle->dhandle.name, "r");
+  if (!file)
+    return gsl_error_from_errno (errno, GSL_ERROR_OPEN_FAILED);
+  err = ov_open (file, &vhandle->ofile, NULL, 0);
+  if (err < 0)
+    {
+      fclose (file);
+      return ov_errno_to_error (err, GSL_ERROR_OPEN_FAILED);
+    }
+#endif
+
+  rfile = gsl_rfile_open (vhandle->dhandle.name);
+  if (!rfile)
+    return gsl_error_from_errno (errno, GSL_ERROR_OPEN_FAILED);
+  err = ov_open_callbacks (rfile, &vhandle->ofile, NULL, 0, rfile_ov_callbacks);
+  if (err < 0)
+    {
+      gsl_rfile_close (rfile);
+      return ov_errno_to_error (err, GSL_ERROR_OPEN_FAILED);
+    }
+
+  n = ov_streams (&vhandle->ofile);
+  if (n > vhandle->stream)
+    vhandle->n_streams = n;
+  else
+    {
+      ov_clear (&vhandle->ofile); /* closes file */
+      return GSL_ERROR_OPEN_FAILED;
+    }
+
+  vhandle->soffset = 0;
+  for (i = 0; i < vhandle->stream; i++)
+    vhandle->soffset += ov_pcm_total (&vhandle->ofile, i);
+
+  n = ov_pcm_total (&vhandle->ofile, vhandle->stream);
+  vi = ov_info (&vhandle->ofile, vhandle->stream);
+  if (n > 0 && vi && vi->channels && ov_pcm_seek (&vhandle->ofile, vhandle->soffset) >= 0)
+    {
+      setup->n_channels = vi->channels;
+      setup->n_values = n * setup->n_channels;
+      setup->bit_depth = 24;
+    }
+  else
+    {
+      ov_clear (&vhandle->ofile); /* closes file */
+      return GSL_ERROR_OPEN_FAILED;
+    }
+
+  vhandle->max_block_size = vorbis_info_blocksize (vi, 0);
+  n = vorbis_info_blocksize (vi, 1);
+  vhandle->max_block_size = MAX (vhandle->max_block_size, n);
+  vhandle->pcm_pos = 0;
+  vhandle->pcm_length = 0;
+  
+  return GSL_ERROR_NONE;
+}
+
+static GslLong
+dh_vorbis_coarse_seek (GslDataHandle *dhandle,
+		       GslLong        voffset)
+{
+  VorbisHandle *vhandle = (VorbisHandle*) dhandle;
+  GslLong opos = vhandle->pcm_pos, pos = voffset / dhandle->setup.n_channels;
+  
+  if (voffset < 0)
+    return vhandle->pcm_pos * dhandle->setup.n_channels;
+
+  if (pos < vhandle->pcm_pos ||
+      pos >= vhandle->pcm_pos + vhandle->pcm_length + SEEK_BY_READ_AHEAD (vhandle))
+    {
+      gint err = ov_pcm_seek_page (&vhandle->ofile, vhandle->soffset + pos);
+
+      if (err)	/* eek */
+	err = ov_pcm_seek_page (&vhandle->ofile, vhandle->soffset);
+      else
+	vhandle->pcm_pos = ov_pcm_tell (&vhandle->ofile) - vhandle->soffset;
+      if (err || vhandle->pcm_pos < 0)  /* urg, we're completely screwed */
+	vhandle->pcm_pos = 0;
+      vhandle->pcm_length = 0;
+    }
+  g_printerr ("OggS-SEEK: at %lu want %lu got %lu (diff-requested %ld)\n",
+	      opos, pos, vhandle->pcm_pos, pos - opos);
+
+  return vhandle->pcm_pos * dhandle->setup.n_channels;
+}
+
+static void
+read_packet (VorbisHandle *vhandle)
+{
+  gfloat **pcm = NULL;
+  gint stream_id, i;
+  
+  vhandle->pcm_pos = ov_pcm_tell (&vhandle->ofile) - vhandle->soffset;
+#if GSL_HAVE_OGGVORBIS_RC3
+  vhandle->pcm_length = ov_read_float (&vhandle->ofile, &pcm, &stream_id);
+#else
+  vhandle->pcm_length = ov_read_float (&vhandle->ofile, &pcm, (~0U>>1), &stream_id);
+#endif
+  if (vhandle->pcm_pos < 0 || vhandle->pcm_length < 0 || stream_id != vhandle->stream)
+    {
+      /* urg, this is bad! */
+      dh_vorbis_coarse_seek (&vhandle->dhandle, 0);
+    }
+  else
+    for (i = 0; i < vhandle->dhandle.setup.n_channels; i++)
+      vhandle->pcm[i] = pcm[i];
+}
+
+static GslLong
+dh_vorbis_read (GslDataHandle *dhandle,
+		GslLong        voffset, /* in values */
+		GslLong        n_values,
+		gfloat        *values)
+{
+  VorbisHandle *vhandle = (VorbisHandle*) dhandle;
+  GslLong pos = voffset / dhandle->setup.n_channels;
+
+  if (pos < vhandle->pcm_pos ||
+      pos >= vhandle->pcm_pos + vhandle->pcm_length + SEEK_BY_READ_AHEAD (vhandle))
+    {
+      GslLong tmp;
+
+      /* suckage, needs to seek in file, this takes ages */
+      tmp = dh_vorbis_coarse_seek (dhandle, voffset);
+      g_assert (tmp <= voffset);
+    }
+
+  while (pos >= vhandle->pcm_pos + vhandle->pcm_length)
+    read_packet (vhandle);
+
+  n_values = MIN (n_values, vhandle->pcm_length * dhandle->setup.n_channels);
+
+  /* interleave into output buffer */
+  if (pos >= vhandle->pcm_pos && pos < vhandle->pcm_pos + vhandle->pcm_length)
+    {
+      guint offset = voffset - vhandle->pcm_pos * dhandle->setup.n_channels;
+      guint align = offset % dhandle->setup.n_channels;
+      guint n_samples = MIN (n_values, vhandle->pcm_length * dhandle->setup.n_channels - offset);
+      gfloat *pcm[MAX_CHANNELS], *bound = values + n_samples;
+      guint i;
+      
+      offset /= dhandle->setup.n_channels;
+      for (i = 0; i < dhandle->setup.n_channels; i++)
+	pcm[i] = vhandle->pcm[i] + offset + (i < align);
+
+      for (i = align; values < bound; values++)
+	{
+	  gfloat f = *(pcm[i]++);
+
+	  f = CLAMP (f, -1.0, 1.0);
+	  *values = f;
+	  if (++i >= dhandle->setup.n_channels)
+	    i = 0;
+	}
+      return n_samples;
+    }
+  else /* something went wrong here, _badly_ */
+    return 0;
+}
+
+static void
+dh_vorbis_close (GslDataHandle *dhandle)
+{
+  VorbisHandle *vhandle = (VorbisHandle*) dhandle;
+
+  ov_clear (&vhandle->ofile);
+  vhandle->pcm_pos = 0;
+  vhandle->pcm_length = 0;
+}
+
+static void
+dh_vorbis_destroy (GslDataHandle *data_handle)
+{
+  VorbisHandle *vhandle = (VorbisHandle*) data_handle;
+
+  gsl_data_handle_common_free (data_handle);
+  gsl_delete_struct (VorbisHandle, vhandle);
+}
+
+static GslDataHandleFuncs dh_vorbis_vtable = {
+  dh_vorbis_open,
+  dh_vorbis_read,
+  dh_vorbis_close,
+  dh_vorbis_destroy,
+  dh_vorbis_coarse_seek,
+};
+
+GslDataHandle*
+gsl_data_handle_new_ogg_vorbis (const gchar *file_name,
+				guint        lbitstream)
+{
+  VorbisHandle *vhandle;
+  gboolean success;
+
+  g_return_val_if_fail (file_name != NULL, NULL);
+
+  vhandle = gsl_new_struct0 (VorbisHandle, 1);
+  success = gsl_data_handle_common_init (&vhandle->dhandle, file_name);
+  if (success)
+    {
+      GslErrorType error;
+
+      vhandle->dhandle.vtable = &dh_vorbis_vtable;
+      vhandle->n_streams = 0;
+      vhandle->stream = lbitstream;
+
+      /* we can only check matters upon opening
+       */
+      error = gsl_data_handle_open (&vhandle->dhandle);
+      if (!error)
+	{
+	  gsl_data_handle_close (&vhandle->dhandle);
+	  return &vhandle->dhandle;
+	}
+      else
+	{
+	  gsl_data_handle_unref (&vhandle->dhandle);
+	  return NULL;
+	}
+    }
+  else
+    {
+      gsl_delete_struct (VorbisHandle, vhandle);
+      return NULL;
+    }
+}
+#endif /* GSL_HAVE_OGGVORBIS */
+
diff --git a/flow/gsl/gsldatahandle-vorbis.h b/flow/gsl/gsldatahandle-vorbis.h
new file mode 100644
index 0000000..8887923
--- /dev/null
+++ b/flow/gsl/gsldatahandle-vorbis.h
@@ -0,0 +1,41 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_DATA_HANDLE_VORBIS_H__
+#define __GSL_DATA_HANDLE_VORBIS_H__
+
+
+#include <gsl/gslcommon.h>
+#include <gsl/gsldatahandle.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* linear-read handle! needs linbuffer handle wrapper
+ */
+GslDataHandle*	gsl_data_handle_new_ogg_vorbis	(const gchar	*file_name,
+						 guint		 lbitstream);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_DATA_HANDLE_VORBIS_H__ */
diff --git a/flow/gsl/gsldatahandle.c b/flow/gsl/gsldatahandle.c
new file mode 100644
index 0000000..c746ec7
--- /dev/null
+++ b/flow/gsl/gsldatahandle.c
@@ -0,0 +1,1241 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsldatahandle.h"
+
+#include "gslcommon.h"
+#include "gsldatacache.h"
+#include "gslfilehash.h"
+
+#include <string.h>
+#include <errno.h>
+
+
+/* --- typedefs --- */
+typedef struct {
+  GslDataHandle     dhandle;
+  guint             n_channels;
+  guint             bit_depth;
+  GslLong           n_values;
+  const gfloat     *values;
+  void            (*free_values) (gpointer);
+} MemHandle;
+typedef struct {
+  GslDataHandle     dhandle;
+  GslDataHandle	   *src_handle;
+} ChainHandle;
+typedef ChainHandle ReversedHandle;
+typedef struct {
+  GslDataHandle     dhandle;
+  GslDataHandle	   *src_handle;	/* mirror ChainHandle */
+  GslLong	    cut_offset;
+  GslLong	    n_cut_values;
+  GslLong	    tail_cut;
+} CutHandle;
+typedef struct {
+  GslDataHandle     dhandle;
+  GslDataHandle	   *src_handle;	/* mirror ChainHandle */
+  GslLong	    requested_paste_offset;
+  GslLong	    paste_offset;
+  GslLong	    n_paste_values;
+  guint		    paste_bit_depth;
+  const gfloat	   *paste_values;
+  void            (*free_values) (gpointer);
+} InsertHandle;
+typedef struct {
+  GslDataHandle     dhandle;
+  GslDataHandle	   *src_handle;	/* mirror ChainHandle */
+  GslLong	    requested_first;
+  GslLong	    requested_last;
+  GslLong	    loop_start;
+  GslLong	    loop_width;
+} LoopHandle;
+typedef struct {
+  GslDataHandle     dhandle;
+  GslDataCache	   *dcache;
+  guint		    node_size;
+} DCacheHandle;
+typedef struct {
+  GslDataHandle     dhandle;
+  guint		    n_channels;
+  GslWaveFormatType format;
+  guint             byte_order;
+  GslLong	    byte_offset;
+  GslLong	    requested_length;
+  GslHFile	   *hfile;
+} WaveHandle;
+
+
+/* --- standard functions --- */
+gboolean
+gsl_data_handle_common_init (GslDataHandle *dhandle,
+			     const gchar   *file_name)
+{
+  g_return_val_if_fail (dhandle != NULL, FALSE);
+  g_return_val_if_fail (dhandle->vtable == NULL, FALSE);
+  g_return_val_if_fail (dhandle->name == NULL, FALSE);
+  g_return_val_if_fail (dhandle->ref_count == 0, FALSE);
+  
+  dhandle->name = g_strdup (file_name);
+  gsl_mutex_init (&dhandle->mutex);
+  dhandle->ref_count = 1;
+  dhandle->open_count = 0;
+  memset (&dhandle->setup, 0, sizeof (dhandle->setup));
+  
+  return TRUE;
+}
+
+GslDataHandle*
+gsl_data_handle_ref (GslDataHandle *dhandle)
+{
+  g_return_val_if_fail (dhandle != NULL, NULL);
+  g_return_val_if_fail (dhandle->ref_count > 0, NULL);
+  
+  GSL_SPIN_LOCK (&dhandle->mutex);
+  dhandle->ref_count++;
+  GSL_SPIN_UNLOCK (&dhandle->mutex);
+  
+  return dhandle;
+}
+
+void
+gsl_data_handle_common_free (GslDataHandle *dhandle)
+{
+  g_return_if_fail (dhandle != NULL);
+  g_return_if_fail (dhandle->vtable != NULL);
+  g_return_if_fail (dhandle->ref_count == 0);
+  
+  g_free (dhandle->name);
+  dhandle->name = NULL;
+  gsl_mutex_destroy (&dhandle->mutex);
+}
+
+void
+gsl_data_handle_unref (GslDataHandle *dhandle)
+{
+  gboolean destroy;
+  
+  g_return_if_fail (dhandle != NULL);
+  g_return_if_fail (dhandle->ref_count > 0);
+  
+  GSL_SPIN_LOCK (&dhandle->mutex);
+  dhandle->ref_count--;
+  destroy = dhandle->ref_count == 0;
+  GSL_SPIN_UNLOCK (&dhandle->mutex);
+  if (destroy)
+    {
+      g_return_if_fail (dhandle->open_count == 0);
+      dhandle->vtable->destroy (dhandle);
+    }
+}
+
+GslErrorType
+gsl_data_handle_open (GslDataHandle *dhandle)
+{
+  g_return_val_if_fail (dhandle != NULL, GSL_ERROR_INTERNAL);
+  g_return_val_if_fail (dhandle->ref_count > 0, GSL_ERROR_INTERNAL);
+
+  GSL_SPIN_LOCK (&dhandle->mutex);
+  if (dhandle->open_count == 0)
+    {
+      GslErrorType error;
+
+      memset (&dhandle->setup, 0, sizeof (dhandle->setup));
+      error = dhandle->vtable->open (dhandle, &dhandle->setup);
+      if (!error && (dhandle->setup.n_values < 0 ||
+		     dhandle->setup.n_channels < 1 ||
+		     dhandle->setup.bit_depth < 1))
+	{
+	  g_warning ("internal error in data handle open() (%p): nv=%ld nc=%u bd=%u",
+		     dhandle->vtable->open, dhandle->setup.n_values, dhandle->setup.n_channels, dhandle->setup.bit_depth);
+	  dhandle->vtable->close (dhandle);
+	  error = GSL_ERROR_INTERNAL;
+	}
+      if (error)
+	{
+	  memset (&dhandle->setup, 0, sizeof (dhandle->setup));
+	  GSL_SPIN_UNLOCK (&dhandle->mutex);
+	  return error;
+	}
+      dhandle->ref_count++;
+      dhandle->open_count++;
+    }
+  else
+    dhandle->open_count++;
+  GSL_SPIN_UNLOCK (&dhandle->mutex);
+  
+  return GSL_ERROR_NONE;
+}
+
+void
+gsl_data_handle_close (GslDataHandle *dhandle)
+{
+  gboolean need_unref;
+  
+  g_return_if_fail (dhandle != NULL);
+  g_return_if_fail (dhandle->ref_count > 0);
+  g_return_if_fail (dhandle->open_count > 0);
+  
+  GSL_SPIN_LOCK (&dhandle->mutex);
+  dhandle->open_count--;
+  need_unref = !dhandle->open_count;
+  if (!dhandle->open_count)
+    dhandle->vtable->close (dhandle);
+  GSL_SPIN_UNLOCK (&dhandle->mutex);
+  if (need_unref)
+    gsl_data_handle_unref (dhandle);
+}
+
+GslLong
+gsl_data_handle_read (GslDataHandle *dhandle,
+		      GslLong        value_offset,
+		      GslLong        n_values,
+		      gfloat        *values)
+{
+  GslLong l;
+  
+  g_return_val_if_fail (dhandle != NULL, -1);
+  g_return_val_if_fail (dhandle->open_count > 0, -1);
+  g_return_val_if_fail (value_offset >= 0, -1);
+  if (n_values < 1)
+    return 0;
+  g_return_val_if_fail (values != NULL, -1);
+  g_return_val_if_fail (value_offset < dhandle->setup.n_values, -1);
+  
+  n_values = MIN (n_values, dhandle->setup.n_values - value_offset);
+  GSL_SPIN_LOCK (&dhandle->mutex);
+  l = dhandle->vtable->read (dhandle, value_offset, n_values, values);
+  GSL_SPIN_UNLOCK (&dhandle->mutex);
+  
+  return l;
+}
+
+GslLong
+gsl_data_handle_length (GslDataHandle *dhandle)
+{
+  GslLong l;
+
+  g_return_val_if_fail (dhandle != NULL, 0);
+  g_return_val_if_fail (dhandle->open_count > 0, 0);
+
+  GSL_SPIN_LOCK (&dhandle->mutex);
+  l = dhandle->open_count ? dhandle->setup.n_values : 0;
+  GSL_SPIN_UNLOCK (&dhandle->mutex);
+
+  return l;
+}
+
+guint
+gsl_data_handle_n_channels (GslDataHandle *dhandle)
+{
+  guint n;
+
+  g_return_val_if_fail (dhandle != NULL, 0);
+  g_return_val_if_fail (dhandle->open_count > 0, 0);
+
+  GSL_SPIN_LOCK (&dhandle->mutex);
+  n = dhandle->open_count ? dhandle->setup.n_channels : 0;
+  GSL_SPIN_UNLOCK (&dhandle->mutex);
+
+  return n;
+}
+
+guint
+gsl_data_handle_bit_depth (GslDataHandle *dhandle)
+{
+  guint n;
+
+  g_return_val_if_fail (dhandle != NULL, 0);
+  g_return_val_if_fail (dhandle->open_count > 0, 0);
+
+  GSL_SPIN_LOCK (&dhandle->mutex);
+  n = dhandle->open_count ? dhandle->setup.bit_depth : 0;
+  GSL_SPIN_UNLOCK (&dhandle->mutex);
+
+  return n;
+}
+
+const gchar*
+gsl_data_handle_name (GslDataHandle *dhandle)
+{
+  g_return_val_if_fail (dhandle != NULL, NULL);
+
+  return dhandle->name;
+}
+
+
+/* --- const memory handle --- */
+static GslErrorType
+mem_handle_open (GslDataHandle      *dhandle,
+		 GslDataHandleSetup *setup)
+{
+  MemHandle *mhandle = (MemHandle*) dhandle;
+
+  setup->n_values = mhandle->n_values;
+  setup->n_channels = mhandle->n_channels;
+  setup->bit_depth = mhandle->bit_depth;
+
+  return GSL_ERROR_NONE;
+}
+
+static void
+mem_handle_close (GslDataHandle *dhandle)
+{
+  /* MemHandle *mhandle = (MemHandle*) dhandle; */
+}
+
+static void
+mem_handle_destroy (GslDataHandle *dhandle)
+{
+  MemHandle *mhandle = (MemHandle*) dhandle;
+  void (*free_values) (gpointer) = mhandle->free_values;
+  const gfloat *mem_values = mhandle->values;
+
+  gsl_data_handle_common_free (dhandle);
+  mhandle->values = NULL;
+  mhandle->free_values = NULL;
+  gsl_delete_struct (MemHandle, mhandle);
+  
+  if (free_values)
+    free_values ((gpointer) mem_values);
+}
+
+static GslLong
+mem_handle_read (GslDataHandle *dhandle,
+		 GslLong        voffset,
+		 GslLong        n_values,
+		 gfloat        *values)
+{
+  MemHandle *mhandle = (MemHandle*) dhandle;
+
+  g_return_val_if_fail (voffset + n_values <= mhandle->n_values, -1);
+
+  memcpy (values, mhandle->values + voffset, n_values * sizeof (values[0]));
+
+  return n_values;
+}
+
+GslDataHandle*
+gsl_data_handle_new_mem (guint         n_channels,
+			 guint         bit_depth,
+			 GslLong       n_values,
+			 const gfloat *values,
+			 void        (*free) (gpointer values))
+{
+  static GslDataHandleFuncs mem_handle_vtable = {
+    mem_handle_open,
+    mem_handle_read,
+    mem_handle_close,
+    mem_handle_destroy,
+  };
+  MemHandle *mhandle;
+  gboolean success;
+
+  g_return_val_if_fail (n_channels > 0, NULL);
+  g_return_val_if_fail (bit_depth > 0, NULL);
+  g_return_val_if_fail (n_values >= n_channels, NULL);
+  if (n_values)
+    g_return_val_if_fail (values != NULL, NULL);
+  
+  mhandle = gsl_new_struct0 (MemHandle, 1);
+  success = gsl_data_handle_common_init (&mhandle->dhandle, NULL);
+  if (success)
+    {
+      mhandle->dhandle.name = g_strconcat ("// #memory /", NULL);
+      mhandle->dhandle.vtable = &mem_handle_vtable;
+      mhandle->n_channels = n_channels;
+      mhandle->bit_depth = bit_depth;
+      mhandle->n_values = n_values / mhandle->n_channels;
+      mhandle->n_values *= mhandle->n_channels;
+      mhandle->values = values;
+      mhandle->free_values = free;
+    }
+  else
+    {
+      gsl_delete_struct (MemHandle, mhandle);
+      return NULL;
+    }
+  return &mhandle->dhandle;
+}
+
+
+/* --- chain handle --- */
+static GslErrorType
+chain_handle_open (GslDataHandle      *dhandle,
+		   GslDataHandleSetup *setup)
+{
+  ChainHandle *chandle = (ChainHandle*) dhandle;
+  GslErrorType error;
+
+  error = gsl_data_handle_open (chandle->src_handle);
+  if (error != GSL_ERROR_NONE)
+    return error;
+  *setup = chandle->src_handle->setup;
+
+  return GSL_ERROR_NONE;
+}
+
+static void
+chain_handle_close (GslDataHandle *dhandle)
+{
+  ChainHandle *chandle = (ChainHandle*) dhandle;
+  
+  gsl_data_handle_close (chandle->src_handle);
+}
+
+
+/* --- reversed handle --- */
+static void
+reverse_handle_destroy (GslDataHandle *data_handle)
+{
+  ReversedHandle *rhandle = (ReversedHandle*) data_handle;
+  
+  gsl_data_handle_unref (rhandle->src_handle);
+  
+  gsl_data_handle_common_free (data_handle);
+  gsl_delete_struct (ReversedHandle, rhandle);
+}
+
+static GslLong
+reverse_handle_read (GslDataHandle *dhandle,
+		     GslLong        voffset,
+		     GslLong        n_values,
+		     gfloat        *values)
+{
+  ReversedHandle *rhandle = (ReversedHandle*) dhandle;
+  GslLong left, new_offset = dhandle->setup.n_values - (voffset + n_values);
+  gfloat *t, *p = values;
+  
+  g_assert (new_offset >= 0);
+  
+  left = n_values;
+  do
+    {
+      GslLong l = gsl_data_handle_read (rhandle->src_handle, new_offset, left, p);
+      
+      if (l < 0)
+	return l;	/* pass on errors */
+      
+      new_offset += l;
+      left -= l;
+      p += l;
+    }
+  while (left > 0);
+  
+  p = values;
+  t = values + n_values - 1;
+  while (p < t)
+    {
+      gfloat v = *t;
+      
+      *t-- = *p;
+      *p++ = v;
+    }
+  return n_values;
+}
+
+GslDataHandle*
+gsl_data_handle_new_reverse (GslDataHandle *src_handle)
+{
+  static GslDataHandleFuncs reverse_handle_vtable = {
+    chain_handle_open,
+    reverse_handle_read,
+    chain_handle_close,
+    reverse_handle_destroy,
+  };
+  ReversedHandle *rhandle;
+  gboolean success;
+  
+  g_return_val_if_fail (src_handle != NULL, NULL);
+  
+  rhandle = gsl_new_struct0 (ReversedHandle, 1);
+  success = gsl_data_handle_common_init (&rhandle->dhandle, NULL);
+  if (success)
+    {
+      rhandle->dhandle.name = g_strconcat (src_handle->name, "// #reversed /", NULL);
+      rhandle->dhandle.vtable = &reverse_handle_vtable;
+      rhandle->src_handle = gsl_data_handle_ref (src_handle);
+    }
+  else
+    {
+      gsl_delete_struct (ReversedHandle, rhandle);
+      return NULL;
+    }
+  return &rhandle->dhandle;
+}
+
+
+/* --- cut handle --- */
+static GslErrorType
+cut_handle_open (GslDataHandle      *dhandle,
+		 GslDataHandleSetup *setup)
+{
+  CutHandle *chandle = (CutHandle*) dhandle;
+  GslErrorType error;
+
+  error = gsl_data_handle_open (chandle->src_handle);
+  if (error != GSL_ERROR_NONE)
+    return error;
+  *setup = chandle->src_handle->setup;
+  setup->n_values -= MIN (setup->n_values, chandle->tail_cut);
+  setup->n_values -= MIN (setup->n_values, chandle->n_cut_values);
+
+  return GSL_ERROR_NONE;
+}
+
+static void
+cut_handle_destroy (GslDataHandle *data_handle)
+{
+  CutHandle *chandle = (CutHandle*) data_handle;
+  
+  gsl_data_handle_unref (chandle->src_handle);
+  
+  gsl_data_handle_common_free (data_handle);
+  gsl_delete_struct (CutHandle, chandle);
+}
+
+static GslLong
+cut_handle_read (GslDataHandle *dhandle,
+		 GslLong        voffset,
+		 GslLong        n_values,
+		 gfloat        *values)
+{
+  CutHandle *chandle = (CutHandle*) dhandle;
+  GslLong orig_n_values = n_values;
+  
+  if (voffset < chandle->cut_offset)
+    {
+      GslLong l = MIN (chandle->cut_offset - voffset, n_values);
+      
+      l = gsl_data_handle_read (chandle->src_handle, voffset, l, values);
+      if (l < 0)
+	return l;	/* pass on errors */
+      n_values -= l;
+      values += l;
+      voffset += l;
+    }
+  
+  if (voffset >= chandle->cut_offset && n_values)
+    {
+      GslLong l = gsl_data_handle_read (chandle->src_handle, voffset + chandle->n_cut_values, n_values, values);
+      
+      if (l < 0 && orig_n_values == n_values)
+	return l;       /* pass on errors */
+      else if (l < 0)
+	l = 0;
+
+      n_values -= l;
+    }
+  
+  return orig_n_values - n_values;
+}
+
+static GslDataHandle*
+gsl_data_handle_new_translate (GslDataHandle *src_handle,
+			       GslLong        cut_offset,
+			       GslLong        n_cut_values,
+			       GslLong	      tail_cut)
+{
+  static GslDataHandleFuncs cut_handle_vtable = {
+    cut_handle_open,
+    cut_handle_read,
+    chain_handle_close,
+    cut_handle_destroy,
+  };
+  CutHandle *chandle;
+  gboolean success;
+  
+  g_return_val_if_fail (src_handle != NULL, NULL);
+  g_return_val_if_fail (cut_offset >= 0 && n_cut_values >= 0 && tail_cut >= 0, NULL);
+  
+  chandle = gsl_new_struct0 (CutHandle, 1);
+  success = gsl_data_handle_common_init (&chandle->dhandle, NULL);
+  if (success)
+    {
+      chandle->dhandle.name = g_strconcat (src_handle->name, "// #translate /", NULL);
+      chandle->dhandle.vtable = &cut_handle_vtable;
+      chandle->src_handle = gsl_data_handle_ref (src_handle);
+      chandle->cut_offset = n_cut_values ? cut_offset : 0;
+      chandle->n_cut_values = n_cut_values;
+      chandle->tail_cut = tail_cut;
+    }
+  else
+    {
+      gsl_delete_struct (CutHandle, chandle);
+      return NULL;
+    }
+  return &chandle->dhandle;
+}
+
+/**
+ * gsl_data_handle_new_cut
+ * @src_handle:   source GslDataHandle
+ * @cut_offset:   offset of gap into @src_handle
+ * @n_cut_values: length of gap in @src_handle
+ * @RETURNS: a newly created data handle
+ *
+ * Create a new data handle containing the contents of @src_handle
+ * minus @n_cut_values at offset @cut_offset.
+ */
+GslDataHandle*
+gsl_data_handle_new_cut (GslDataHandle *src_handle,
+			 GslLong        cut_offset,
+			 GslLong        n_cut_values)
+{
+  return gsl_data_handle_new_translate (src_handle, cut_offset, n_cut_values, 0);
+}
+
+/**
+ * gsl_data_handle_new_crop
+ * @src_handle: source GslDataHandle
+ * @n_head_cut: number of values to cut at data handle head
+ * @n_tail_cut: number of values to cut at data handle tail
+ * @RETURNS: a newly created data handle
+ *
+ * Create a new data handle containing the contents of @src_handle
+ * minus @n_head_cut values at the start and @n_tail_cut values at
+ * the end.
+ */
+GslDataHandle*
+gsl_data_handle_new_crop (GslDataHandle *src_handle,
+			  GslLong        n_head_cut,
+			  GslLong        n_tail_cut)
+{
+  return gsl_data_handle_new_translate (src_handle, 0, n_head_cut, n_tail_cut);
+}
+
+
+/* --- insert handle --- */
+static GslErrorType
+insert_handle_open (GslDataHandle      *dhandle,
+		    GslDataHandleSetup *setup)
+{
+  InsertHandle *ihandle = (InsertHandle*) dhandle;
+  GslErrorType error;
+
+  error = gsl_data_handle_open (ihandle->src_handle);
+  if (error != GSL_ERROR_NONE)
+    return error;
+  *setup = ihandle->src_handle->setup;
+  ihandle->paste_offset = ihandle->requested_paste_offset < 0 ? setup->n_values : ihandle->requested_paste_offset;
+  if (setup->n_values < ihandle->paste_offset)
+    setup->n_values = ihandle->paste_offset + ihandle->n_paste_values;
+  else
+    setup->n_values += ihandle->n_paste_values;
+  setup->bit_depth = MAX (setup->bit_depth, ihandle->paste_bit_depth);
+
+  return GSL_ERROR_NONE;
+}
+
+static void
+insert_handle_destroy (GslDataHandle *data_handle)
+{
+  InsertHandle *ihandle = (InsertHandle*) data_handle;
+  void (*free_values) (gpointer) = ihandle->free_values;
+  const gfloat *paste_values = ihandle->paste_values;
+  
+  gsl_data_handle_unref (ihandle->src_handle);
+  
+  gsl_data_handle_common_free (data_handle);
+  ihandle->paste_values = NULL;
+  ihandle->free_values = NULL;
+  gsl_delete_struct (InsertHandle, ihandle);
+  
+  if (free_values)
+    free_values ((gpointer) paste_values);
+}
+
+static GslLong
+insert_handle_read (GslDataHandle *data_handle,
+		    GslLong        voffset,
+		    GslLong        n_values,
+		    gfloat        *values)
+{
+  InsertHandle *ihandle = (InsertHandle*) data_handle;
+  GslLong l, orig_n_values = n_values;
+  
+  if (voffset < ihandle->src_handle->setup.n_values &&
+      voffset < ihandle->paste_offset)
+    {
+      l = MIN (n_values, MIN (ihandle->paste_offset, ihandle->src_handle->setup.n_values) - voffset);
+      l = gsl_data_handle_read (ihandle->src_handle, voffset, l, values);
+      if (l < 0)
+	return l;       /* pass on errors */
+      
+      voffset += l;
+      n_values -= l;
+      values += l;
+    }
+
+  if (n_values && voffset >= ihandle->src_handle->setup.n_values && voffset < ihandle->paste_offset)
+    {
+      l = MIN (n_values, ihandle->paste_offset - voffset);
+      memset (values, 0, l * sizeof (values[0]));
+      voffset += l;
+      n_values -= l;
+      values += l;
+    }
+
+  if (n_values && voffset >= ihandle->paste_offset && voffset < ihandle->paste_offset + ihandle->n_paste_values)
+    {
+      l = MIN (n_values, ihandle->paste_offset + ihandle->n_paste_values - voffset);
+      memcpy (values, ihandle->paste_values + voffset - ihandle->paste_offset, l * sizeof (values[0]));
+      voffset += l;
+      n_values -= l;
+      values += l;
+    }
+  
+  if (n_values && voffset >= ihandle->paste_offset + ihandle->n_paste_values)
+    {
+      l = gsl_data_handle_read (ihandle->src_handle, voffset - ihandle->n_paste_values, n_values, values);
+      if (l < 0 && orig_n_values == n_values)
+	return l;       /* pass on errors */
+      else if (l < 0)
+	l = 0;
+      n_values -= l;
+    }
+  
+  return orig_n_values - n_values;
+}
+
+GslDataHandle*
+gsl_data_handle_new_insert (GslDataHandle *src_handle,
+			    guint          paste_bit_depth,
+			    GslLong        insertion_offset,
+			    GslLong        n_paste_values,
+			    const gfloat  *paste_values,
+			    void         (*free) (gpointer values))
+{
+  static GslDataHandleFuncs insert_handle_vtable = {
+    insert_handle_open,
+    insert_handle_read,
+    chain_handle_close,
+    insert_handle_destroy,
+  };
+  InsertHandle *ihandle;
+  gboolean success;
+  
+  g_return_val_if_fail (src_handle != NULL, NULL);
+  g_return_val_if_fail (n_paste_values >= 0, NULL);
+  if (n_paste_values)
+    g_return_val_if_fail (paste_values != NULL, NULL);
+  
+  ihandle = gsl_new_struct0 (InsertHandle, 1);
+  success = gsl_data_handle_common_init (&ihandle->dhandle, NULL);
+  if (success)
+    {
+      ihandle->dhandle.name = g_strconcat (src_handle ? src_handle->name : "", "// #insert /", NULL);
+      ihandle->dhandle.vtable = &insert_handle_vtable;
+      ihandle->src_handle = gsl_data_handle_ref (src_handle);
+      ihandle->requested_paste_offset = insertion_offset;
+      ihandle->paste_offset = 0;
+      ihandle->n_paste_values = n_paste_values;
+      ihandle->paste_bit_depth = paste_bit_depth;
+      ihandle->paste_values = paste_values;
+      ihandle->free_values = free;
+    }
+  else
+    {
+      gsl_delete_struct (InsertHandle, ihandle);
+      return NULL;
+    }
+  return &ihandle->dhandle;
+}
+
+
+/* --- loop handle --- */
+static GslErrorType
+loop_handle_open (GslDataHandle      *dhandle,
+		  GslDataHandleSetup *setup)
+{
+  LoopHandle *lhandle = (LoopHandle*) dhandle;
+  GslErrorType error;
+
+  error = gsl_data_handle_open (lhandle->src_handle);
+  if (error != GSL_ERROR_NONE)
+    return error;
+
+  *setup = lhandle->src_handle->setup;
+  if (setup->n_values > lhandle->requested_last)
+    {
+      lhandle->loop_start = lhandle->requested_first;
+      lhandle->loop_width = lhandle->requested_last - lhandle->requested_first + 1;
+      setup->n_values = GSL_MAXLONG;
+    }
+  else	/* cannot loop */
+    {
+      lhandle->loop_start = setup->n_values;
+      lhandle->loop_width = 0;
+    }
+
+  return GSL_ERROR_NONE;
+}
+
+static void
+loop_handle_destroy (GslDataHandle *data_handle)
+{
+  LoopHandle *lhandle = (LoopHandle*) data_handle;
+  
+  gsl_data_handle_unref (lhandle->src_handle);
+  
+  gsl_data_handle_common_free (data_handle);
+  gsl_delete_struct (LoopHandle, lhandle);
+}
+
+static GslLong
+loop_handle_read (GslDataHandle *data_handle,
+		  GslLong        voffset,
+		  GslLong        n_values,
+		  gfloat        *values)
+{
+  LoopHandle *lhandle = (LoopHandle*) data_handle;
+  
+  if (voffset < lhandle->loop_start)
+    return gsl_data_handle_read (lhandle->src_handle, voffset,
+				 MIN (lhandle->loop_start - voffset, n_values),
+				 values);
+  else
+    {
+      GslLong noffset = voffset - lhandle->loop_start;
+      
+      noffset %= lhandle->loop_width;
+      
+      return gsl_data_handle_read (lhandle->src_handle,
+				   lhandle->loop_start + noffset,
+				   MIN (lhandle->loop_width - noffset, n_values),
+				   values);
+    }
+}
+
+GslDataHandle*
+gsl_data_handle_new_looped (GslDataHandle *src_handle,
+			    GslLong        loop_first,
+			    GslLong        loop_last)
+{
+  static GslDataHandleFuncs loop_handle_vtable = {
+    loop_handle_open,
+    loop_handle_read,
+    chain_handle_close,
+    loop_handle_destroy,
+  };
+  LoopHandle *lhandle;
+  gboolean success;
+  
+  g_return_val_if_fail (src_handle != NULL, NULL);
+  g_return_val_if_fail (loop_first >= 0, NULL);
+  g_return_val_if_fail (loop_last >= loop_first, NULL);
+  
+  lhandle = gsl_new_struct0 (LoopHandle, 1);
+  success = gsl_data_handle_common_init (&lhandle->dhandle, NULL);
+  if (success)
+    {
+      lhandle->dhandle.name = g_strdup_printf ("%s// #loop(0x%lx:0x%lx) /", src_handle->name, loop_first, loop_last);
+      lhandle->dhandle.vtable = &loop_handle_vtable;
+      lhandle->src_handle = gsl_data_handle_ref (src_handle);
+      lhandle->requested_first = loop_first;
+      lhandle->requested_last = loop_last;
+      lhandle->loop_start = 0;
+      lhandle->loop_width = 0;
+    }
+  else
+    {
+      gsl_delete_struct (LoopHandle, lhandle);
+      return NULL;
+    }
+  return &lhandle->dhandle;
+}
+
+
+/* --- dcache handle --- */
+static void
+dcache_handle_destroy (GslDataHandle *data_handle)
+{
+  DCacheHandle *dhandle = (DCacheHandle*) data_handle;
+  
+  gsl_data_cache_unref (dhandle->dcache);
+  
+  gsl_data_handle_common_free (data_handle);
+  gsl_delete_struct (DCacheHandle, dhandle);
+}
+
+static GslErrorType
+dcache_handle_open (GslDataHandle      *dhandle,
+		    GslDataHandleSetup *setup)
+{
+  DCacheHandle *chandle = (DCacheHandle*) dhandle;
+  GslErrorType error;
+
+  error = gsl_data_handle_open (chandle->dcache->dhandle);
+  if (error != GSL_ERROR_NONE)
+    return error;
+  gsl_data_cache_open (chandle->dcache);
+  *setup = chandle->dcache->dhandle->setup;
+  gsl_data_handle_close (chandle->dcache->dhandle);
+
+  return GSL_ERROR_NONE;
+}
+
+static void
+dcache_handle_close (GslDataHandle *data_handle)
+{
+  DCacheHandle *dhandle = (DCacheHandle*) data_handle;
+  
+  gsl_data_cache_close (dhandle->dcache);
+}
+
+static GslLong
+dcache_handle_read (GslDataHandle *data_handle,
+		    GslLong        voffset,
+		    GslLong        n_values,
+		    gfloat        *values)
+{
+  DCacheHandle *dhandle = (DCacheHandle*) data_handle;
+  GslDataCacheNode *node;
+  
+  node = gsl_data_cache_ref_node (dhandle->dcache, voffset, TRUE);
+  voffset -= node->offset;
+  n_values = MIN (n_values, dhandle->node_size - voffset);
+  memcpy (values, node->data + voffset, sizeof (values[0]) * n_values);
+  
+  return n_values;
+}
+
+GslDataHandle*
+gsl_data_handle_new_dcached (GslDataCache *dcache)
+{
+  static GslDataHandleFuncs dcache_handle_vtable = {
+    dcache_handle_open,
+    dcache_handle_read,
+    dcache_handle_close,
+    dcache_handle_destroy,
+  };
+  DCacheHandle *dhandle;
+  gboolean success;
+  
+  g_return_val_if_fail (dcache != NULL, NULL);
+  
+  dhandle = gsl_new_struct0 (DCacheHandle, 1);
+  success = gsl_data_handle_common_init (&dhandle->dhandle, NULL);
+  if (success)
+    {
+      dhandle->dhandle.name = g_strdup_printf ("%s// #dcache /", dcache->dhandle->name);
+      dhandle->dhandle.vtable = &dcache_handle_vtable;
+      dhandle->dcache = gsl_data_cache_ref (dcache);
+      dhandle->node_size = GSL_DATA_CACHE_NODE_SIZE (dcache) + dcache->padding;
+    }
+  else
+    {
+      gsl_delete_struct (DCacheHandle, dhandle);
+      return NULL;
+    }
+  return &dhandle->dhandle;
+}
+
+
+/* --- wave handle --- */
+static inline const guint G_GNUC_CONST
+wave_format_bit_depth (const GslWaveFormatType format)
+{
+  switch (format)
+    {
+    case GSL_WAVE_FORMAT_UNSIGNED_8:
+    case GSL_WAVE_FORMAT_SIGNED_8:
+      return 8;
+    case GSL_WAVE_FORMAT_UNSIGNED_12:
+    case GSL_WAVE_FORMAT_SIGNED_12:
+      return 12;
+    case GSL_WAVE_FORMAT_UNSIGNED_16:
+    case GSL_WAVE_FORMAT_SIGNED_16:
+      return 16;
+    case GSL_WAVE_FORMAT_FLOAT:
+      return 32;
+    default:
+      return 0;
+    }
+}
+#define	wave_format_byte_width(f)	((wave_format_bit_depth (f) + 7) / 8)
+
+static void
+wave_handle_destroy (GslDataHandle *data_handle)
+{
+  WaveHandle *whandle = (WaveHandle*) data_handle;
+
+  gsl_data_handle_common_free (data_handle);
+  gsl_delete_struct (WaveHandle, whandle);
+}
+
+static GslErrorType
+wave_handle_open (GslDataHandle      *data_handle,
+		  GslDataHandleSetup *setup)
+{
+  WaveHandle *whandle = (WaveHandle*) data_handle;
+
+  whandle->hfile = gsl_hfile_open (whandle->dhandle.name);
+  if (!whandle->hfile)
+    return gsl_error_from_errno (errno, GSL_ERROR_OPEN_FAILED);
+  else
+    {
+      GslLong l, fwidth = wave_format_byte_width (whandle->format);
+      /* convert size into n_values, i.e. float length */
+      l = whandle->hfile->n_bytes;
+      l -= MIN (l, whandle->byte_offset);
+      if (l >= fwidth)
+	{
+	  l /= fwidth;
+	  if (whandle->requested_length < 0)
+	    setup->n_values = l;
+	  else
+	    setup->n_values = MIN (l, whandle->requested_length);
+	}
+      else
+	setup->n_values = 0;
+      setup->n_channels = whandle->n_channels;
+      setup->bit_depth = wave_format_bit_depth (whandle->format);
+      return GSL_ERROR_NONE;
+    }
+}
+
+static void
+wave_handle_close (GslDataHandle *dhandle)
+{
+  WaveHandle *whandle = (WaveHandle*) dhandle;
+  
+  gsl_hfile_close (whandle->hfile);
+  whandle->hfile = NULL;
+}
+
+static GslLong
+wave_handle_read (GslDataHandle *data_handle,
+		  GslLong        voffset,
+		  GslLong        n_values,
+		  gfloat        *values)
+{
+  WaveHandle *whandle = (WaveHandle*) data_handle;
+  gpointer buffer = values;
+  GslLong l, i, byte_offset;
+
+  byte_offset = voffset * wave_format_byte_width (whandle->format);	/* float offset into bytes */
+  byte_offset += whandle->byte_offset;
+
+  switch (whandle->format)
+    {
+      guint8 *u8; gint8 *s8; guint16 *u16; guint32 *u32;
+    case GSL_WAVE_FORMAT_UNSIGNED_8:
+      u8 = buffer; u8 += n_values * 3;
+      l = gsl_hfile_pread (whandle->hfile, byte_offset, n_values, u8);
+      if (l < 1)
+	return l;
+      for (i = 0; i < l; i++)
+	{
+	  int v = u8[i] - 128;
+	  values[i] = v * (1. / 128.);
+	}
+      break;
+    case GSL_WAVE_FORMAT_SIGNED_8:
+      s8 = buffer; s8 += n_values * 3;
+      l = gsl_hfile_pread (whandle->hfile, byte_offset, n_values, s8);
+      if (l < 1)
+	return l;
+      for (i = 0; i < l; i++)
+	values[i] = s8[i] * (1. / 128.);
+      break;
+    case GSL_WAVE_FORMAT_SIGNED_12:
+    case GSL_WAVE_FORMAT_UNSIGNED_12:
+    case GSL_WAVE_FORMAT_SIGNED_16:
+    case GSL_WAVE_FORMAT_UNSIGNED_16:
+      u16 = buffer; u16 += n_values;
+      l = gsl_hfile_pread (whandle->hfile, byte_offset, n_values << 1, u16);
+      if (l < 2)
+	return l < 0 ? l : 0;
+      l >>= 1;
+      switch (whandle->format)
+	{
+	case GSL_WAVE_FORMAT_UNSIGNED_16:
+	  if (whandle->byte_order != G_BYTE_ORDER)
+	    for (i = 0; i < l; i++)
+	      {
+		int v = GUINT16_SWAP_LE_BE (u16[i]); v -= 32768;
+		values[i] = v * (1. / 32768.);
+	      }
+	  else /* whandle->byte_order == G_BYTE_ORDER */
+	    for (i = 0; i < l; i++)
+	      {
+		int v = u16[i]; v -= 32768;
+		values[i] = v * (1. / 32768.);
+	      }
+	  break;
+	case GSL_WAVE_FORMAT_UNSIGNED_12:
+	  if (whandle->byte_order != G_BYTE_ORDER)
+	    for (i = 0; i < l; i++)
+	      {
+		int v = GUINT16_SWAP_LE_BE (u16[i]); v &= 0x0fff; v -= 4096;
+		values[i] = v * (1. / 4096.);
+	      }
+	  else /* whandle->byte_order == G_BYTE_ORDER */
+	    for (i = 0; i < l; i++)
+	      {
+		int v = u16[i]; v &= 0x0fff; v -= 4096;
+		values[i] = v * (1. / 4096.);
+	      }
+	  break;
+	case GSL_WAVE_FORMAT_SIGNED_16:
+	  if (whandle->byte_order != G_BYTE_ORDER)
+	    for (i = 0; i < l; i++)
+	      {
+		gint16 v = GUINT16_SWAP_LE_BE (u16[i]);
+		values[i] = v * (1. / 32768.);
+	      }
+	  else /* whandle->byte_order == G_BYTE_ORDER */
+	    for (i = 0; i < l; i++)
+	      {
+		gint16 v = u16[i];
+		values[i] = v * (1. / 32768.);
+	      }
+	  break;
+	case GSL_WAVE_FORMAT_SIGNED_12:
+	  if (whandle->byte_order != G_BYTE_ORDER)
+	    for (i = 0; i < l; i++)
+	      {
+		gint16 v = GUINT16_SWAP_LE_BE (u16[i]);
+		values[i] = CLAMP (v, -4096, 4096) * (1. / 4096.);
+	      }
+	  else /* whandle->byte_order == G_BYTE_ORDER */
+	    for (i = 0; i < l; i++)
+	      {
+		gint16 v = u16[i];
+		values[i] = CLAMP (v, -4096, 4096) * (1. / 4096.);
+	      }
+	  break;
+	default:
+	  g_assert_not_reached ();
+	}
+      break;
+    case GSL_WAVE_FORMAT_FLOAT:
+      u32 = buffer;
+      l = gsl_hfile_pread (whandle->hfile, byte_offset, n_values << 2, u32);
+      if (l < 4)
+	return l < 0 ? l : 0;
+      l >>= 2;
+      if (whandle->byte_order != G_BYTE_ORDER)
+	for (i = 0; i < l; i++)
+	  u32[i] = GUINT32_SWAP_LE_BE (u32[i]);
+      break;
+    default:
+      l = -1;
+      g_assert_not_reached ();
+    }
+  
+  return l;
+}
+
+GslDataHandle*
+gsl_wave_handle_new (const gchar      *file_name,
+		     guint             n_channels,
+		     GslWaveFormatType format,
+		     guint             byte_order,
+		     GslLong           byte_offset,
+		     GslLong           n_values)
+{
+  static GslDataHandleFuncs wave_handle_vtable = {
+    wave_handle_open,
+    wave_handle_read,
+    wave_handle_close,
+    wave_handle_destroy,
+  };
+  WaveHandle *whandle;
+
+  g_return_val_if_fail (file_name != NULL, NULL);
+  g_return_val_if_fail (format > GSL_WAVE_FORMAT_NONE && format < GSL_WAVE_FORMAT_LAST, NULL);
+  g_return_val_if_fail (byte_order == G_LITTLE_ENDIAN || byte_order == G_BIG_ENDIAN, NULL);
+  g_return_val_if_fail (byte_offset >= 0, NULL);
+  g_return_val_if_fail (n_channels >= 1, NULL);
+  g_return_val_if_fail (n_values >= 1 || n_values == -1, NULL);
+
+  whandle = gsl_new_struct0 (WaveHandle, 1);
+  if (gsl_data_handle_common_init (&whandle->dhandle, file_name))
+    {
+      whandle->dhandle.vtable = &wave_handle_vtable;
+      whandle->n_channels = n_channels;
+      whandle->format = format;
+      whandle->byte_order = byte_order;
+      whandle->byte_offset = byte_offset;
+      whandle->requested_length = n_values;
+      whandle->hfile = NULL;
+      return &whandle->dhandle;
+    }
+  else
+    {
+      gsl_delete_struct (WaveHandle, whandle);
+      return NULL;
+    }
+}
+
+const gchar*
+gsl_wave_format_to_string (GslWaveFormatType format)
+{
+  switch (format)
+    {
+    case GSL_WAVE_FORMAT_UNSIGNED_8:    return "unsigned_8";
+    case GSL_WAVE_FORMAT_SIGNED_8:      return "signed_8";
+    case GSL_WAVE_FORMAT_UNSIGNED_12:   return "unsigned_12";
+    case GSL_WAVE_FORMAT_SIGNED_12:     return "signed_12";
+    case GSL_WAVE_FORMAT_UNSIGNED_16:   return "unsigned_16";
+    case GSL_WAVE_FORMAT_SIGNED_16:     return "signed_16";
+    case GSL_WAVE_FORMAT_FLOAT:         return "float";
+    case GSL_WAVE_FORMAT_NONE:
+    case GSL_WAVE_FORMAT_LAST:
+    default:
+      g_return_val_if_fail (format >= GSL_WAVE_FORMAT_UNSIGNED_8 && format <= GSL_WAVE_FORMAT_FLOAT, NULL);
+      return NULL;
+    }
+}
+
+GslWaveFormatType
+gsl_wave_format_from_string (const gchar *string)
+{
+  gboolean is_unsigned = FALSE;
+
+  g_return_val_if_fail (string != NULL, GSL_WAVE_FORMAT_NONE);
+
+  while (*string == ' ')
+    string++;
+  if (strncasecmp (string, "float", 5) == 0)
+    return GSL_WAVE_FORMAT_FLOAT;
+  if ((string[0] == 'u' || string[0] == 'U') &&
+      (string[1] == 'n' || string[1] == 'N'))
+    {
+      is_unsigned = TRUE;
+      string += 2;
+    }
+  if (strncasecmp (string, "signed", 6) != 0)
+    return GSL_WAVE_FORMAT_NONE;
+  string += 6;
+  if (string[0] != '-' && string[0] != '_')
+    return GSL_WAVE_FORMAT_NONE;
+  string += 1;
+  if (string[0] == '8')
+    return is_unsigned ? GSL_WAVE_FORMAT_UNSIGNED_8 : GSL_WAVE_FORMAT_SIGNED_8;
+  if (string[0] != '1')
+    return GSL_WAVE_FORMAT_NONE;
+  string += 1;
+  if (string[0] == '2')
+    return is_unsigned ? GSL_WAVE_FORMAT_UNSIGNED_12 : GSL_WAVE_FORMAT_SIGNED_12;
+  if (string[0] == '6')
+    return is_unsigned ? GSL_WAVE_FORMAT_UNSIGNED_16 : GSL_WAVE_FORMAT_SIGNED_16;
+  return GSL_WAVE_FORMAT_NONE;
+}
diff --git a/flow/gsl/gsldatahandle.h b/flow/gsl/gsldatahandle.h
new file mode 100644
index 0000000..d67b44f
--- /dev/null
+++ b/flow/gsl/gsldatahandle.h
@@ -0,0 +1,143 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_DATA_HANDLE_H__
+#define __GSL_DATA_HANDLE_H__
+
+#include <gsl/gsldefs.h>
+#include <gsl/gslcommon.h>	/* GslErrorType */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- macros --- */
+#define	GSL_DATA_HANDLE_OPENED(handle)	    (((GslDataHandle*) (handle))->open_count > 0)
+#define	GSL_DATA_HANDLE_READ_LINEAR(handle) (((GslDataHandle*) (handle))->vtable->coarse_seek != NULL)
+
+
+/* --- typedefs & structures --- */
+typedef struct {
+  GslLong	n_values;
+  guint		n_channels;
+  guint		bit_depth;
+} GslDataHandleSetup;
+struct _GslDataHandle
+{
+  /* constant members */
+  GslDataHandleFuncs *vtable;
+  gchar		     *name;
+  /* common members */
+  GslMutex	      mutex;
+  guint		      ref_count;
+  guint		      open_count;
+  /* opened data handle setup (open_count > 0) */
+  GslDataHandleSetup  setup;
+};
+struct _GslDataHandleFuncs
+{
+  GslErrorType	(*open)			(GslDataHandle		*data_handle,
+					 GslDataHandleSetup	*setup);
+  GslLong	(*read)			(GslDataHandle		*data_handle,
+					 GslLong		 voffset, /* in values */
+					 GslLong		 n_values,
+					 gfloat			*values);
+  void		(*close)		(GslDataHandle		*data_handle);
+  void          (*destroy)		(GslDataHandle		*data_handle);
+  /* optional (for codecs) */
+  GslLong	(*coarse_seek)		(GslDataHandle		*data_handle,
+					 GslLong		 position);
+};
+
+
+
+/* --- standard functions --- */
+GslDataHandle*	  gsl_data_handle_ref		(GslDataHandle	  *dhandle);
+void		  gsl_data_handle_unref		(GslDataHandle	  *dhandle);
+GslErrorType	  gsl_data_handle_open		(GslDataHandle	  *dhandle);
+void		  gsl_data_handle_close		(GslDataHandle	  *dhandle);
+GslLong		  gsl_data_handle_length	(GslDataHandle	  *data_handle);
+#define	          gsl_data_handle_n_values(      dh) \
+		                                 gsl_data_handle_length (dh)
+guint		  gsl_data_handle_n_channels	(GslDataHandle	  *data_handle);
+guint		  gsl_data_handle_bit_depth	(GslDataHandle	  *data_handle);
+const gchar*	  gsl_data_handle_name		(GslDataHandle	  *data_handle);
+GslLong		  gsl_data_handle_read		(GslDataHandle	  *data_handle,
+						 GslLong	   value_offset,
+						 GslLong	   n_values,
+						 gfloat		  *values);
+GslDataHandle*	  gsl_data_handle_new_cut	(GslDataHandle	  *src_handle,
+						 GslLong	   cut_offset,
+						 GslLong	   n_cut_values);
+GslDataHandle*	  gsl_data_handle_new_crop	(GslDataHandle	  *src_handle,
+						 GslLong	   n_head_cut,
+						 GslLong	   n_tail_cut);
+GslDataHandle*	  gsl_data_handle_new_reverse	(GslDataHandle	  *src_handle);
+GslDataHandle*	  gsl_data_handle_new_insert	(GslDataHandle	  *src_handle,
+						 guint             paste_bit_depth,
+						 GslLong	   insertion_offset,
+						 GslLong	   n_paste_values,
+						 const gfloat	  *paste_values,
+						 void            (*free) (gpointer values));
+GslDataHandle*	  gsl_data_handle_new_mem	(guint		   n_channels,
+						 guint             bit_depth,
+						 GslLong	   n_values,
+						 const gfloat	  *values,
+						 void            (*free) (gpointer values));
+GslDataHandle*	  gsl_data_handle_new_dcached	(GslDataCache	  *dcache);
+/* cheap and inefficient, testpurpose only */
+GslDataHandle*	  gsl_data_handle_new_looped	(GslDataHandle	  *src_handle,
+						 GslLong	   loop_first,
+						 GslLong	   loop_last);
+
+
+/* --- wave specific functions --- */
+typedef enum    /*< skip >*/
+{
+  GSL_WAVE_FORMAT_NONE,
+  GSL_WAVE_FORMAT_UNSIGNED_8,
+  GSL_WAVE_FORMAT_SIGNED_8,
+  GSL_WAVE_FORMAT_UNSIGNED_12,
+  GSL_WAVE_FORMAT_SIGNED_12,
+  GSL_WAVE_FORMAT_UNSIGNED_16,
+  GSL_WAVE_FORMAT_SIGNED_16,
+  GSL_WAVE_FORMAT_FLOAT,
+  GSL_WAVE_FORMAT_LAST
+} GslWaveFormatType;
+
+const gchar*      gsl_wave_format_to_string     (GslWaveFormatType format);
+GslWaveFormatType gsl_wave_format_from_string   (const gchar      *string);
+GslDataHandle*	  gsl_wave_handle_new		(const gchar	  *file_name,
+						 guint		   n_channels,
+						 GslWaveFormatType format,
+						 guint		   byte_order,
+						 GslLong	   byte_offset,
+						 GslLong	   n_values);
+
+
+/* --- auxillary functions --- */
+gboolean	  gsl_data_handle_common_init	(GslDataHandle	  *dhandle,
+						 const gchar	  *file_name);
+void		  gsl_data_handle_common_free	(GslDataHandle	  *dhandle);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_DATA_HANDLE_H__ */
diff --git a/flow/gsl/gsldatautils.c b/flow/gsl/gsldatautils.c
new file mode 100644
index 0000000..d8c52c0
--- /dev/null
+++ b/flow/gsl/gsldatautils.c
@@ -0,0 +1,462 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Stefan Westerfeld and Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsldatautils.h"
+#include "gsldatacache.h"
+#include <errno.h>
+#include <unistd.h>
+
+
+#define	BSIZE		GSL_DATA_HANDLE_PEEK_BUFFER	/* FIXME: global buffer size setting */
+
+
+/* --- functions --- */
+gfloat
+gsl_data_peek_value_f (GslDataHandle     *dhandle,
+		       GslLong            pos,
+		       GslDataPeekBuffer *peekbuf)
+{
+  if (pos < peekbuf->start || pos >= peekbuf->end)
+    {
+      GslLong dhandle_length = dhandle->setup.n_values;
+      GslLong inc, k, bsize = MIN (GSL_DATA_HANDLE_PEEK_BUFFER, dhandle_length);
+
+      g_return_val_if_fail (pos >= 0 && pos < dhandle_length, 0);
+
+      peekbuf->start = peekbuf->dir > 0 ? pos : peekbuf->dir < 0 ? pos - bsize + 1: pos - bsize / 2;
+      peekbuf->end = MIN (peekbuf->start + bsize, dhandle_length);
+      peekbuf->start = MAX (peekbuf->start, 0);
+      for (k = peekbuf->start; k < peekbuf->end; k += inc)
+	{
+	  guint n_retries = 5;  /* FIXME: need global retry strategy */
+
+	  do
+	    inc = gsl_data_handle_read (dhandle, k, peekbuf->end - k, peekbuf->data + k - peekbuf->start);
+	  while (inc < 1 && n_retries-- && GSL_DATA_HANDLE_OPENED (dhandle));
+	  if (inc < 1)
+	    {   /* pathologic */
+	      peekbuf->data[k - peekbuf->start] = 0;
+	      inc = 1;
+	      gsl_message_send (GSL_MSG_DATA_HANDLE, "PeekBuffer",
+				GSL_ERROR_READ_FAILED, "unable to read from data handle (%p)", dhandle);
+	    }
+	}
+    }
+  return peekbuf->data[pos - peekbuf->start];
+}
+
+gint /* errno */
+gsl_data_handle_dump (GslDataHandle    *dhandle,
+		      gint	        fd,
+		      GslWaveFormatType format,
+		      guint             byte_order)
+{
+  GslLong l, offs = 0;
+
+  g_return_val_if_fail (dhandle != NULL, EINVAL);
+  g_return_val_if_fail (GSL_DATA_HANDLE_OPENED (dhandle), EINVAL);
+  g_return_val_if_fail (fd >= 0, EINVAL);
+  g_return_val_if_fail (format >= GSL_WAVE_FORMAT_UNSIGNED_8 && format <= GSL_WAVE_FORMAT_FLOAT, EINVAL);
+  g_return_val_if_fail (byte_order == G_LITTLE_ENDIAN || byte_order == G_BIG_ENDIAN, EINVAL);
+
+  l = dhandle->setup.n_values;
+  while (l)
+    {
+      GslLong retry, j, n = MIN (l, GSL_DATA_HANDLE_PEEK_BUFFER);
+      gfloat src[GSL_DATA_HANDLE_PEEK_BUFFER];
+
+      retry = GSL_N_IO_RETRIES;
+      do
+	n = gsl_data_handle_read (dhandle, offs, n, src);
+      while (n < 1 && retry--);
+      if (retry < 0)
+	return EIO;
+
+      l -= n;
+      offs += n;
+
+      n = gsl_conv_from_float_clip (format, byte_order, src, src, n);
+
+      do
+	j = write (fd, src, n);
+      while (j < 0 && errno == EINTR);
+      if (j < 0)
+	return errno ? errno : EIO;
+    }
+  return 0;
+}
+
+static void
+write_bytes (gint        fd,
+	     guint       n_bytes,
+	     const void *bytes)
+{
+  gint errold = errno;
+  guint j;
+
+  do
+    j = write (fd, bytes, n_bytes);
+  while (j < 0 && errno == EINTR);
+
+  if (!errno)
+    errno = errold;
+}
+
+static void
+write_uint32_le (gint    fd,
+		 guint32 val)
+{
+  val = GUINT32_TO_LE (val);
+  write_bytes (fd, 4, &val);
+}
+
+static void
+write_uint16_le (gint    fd,
+		 guint16 val)
+{
+  val = GUINT16_TO_LE (val);
+  write_bytes (fd, 2, &val);
+}
+
+gint /* errno */
+gsl_data_handle_dump_wav (GslDataHandle *dhandle,
+			  gint           fd,
+			  guint          n_bits,
+			  guint          n_channels,
+			  guint          sample_freq)
+{
+  guint data_length, file_length, byte_per_sample, byte_per_second;
+
+  g_return_val_if_fail (dhandle != NULL, EINVAL);
+  g_return_val_if_fail (GSL_DATA_HANDLE_OPENED (dhandle), EINVAL);
+  g_return_val_if_fail (fd >= 0, EINVAL);
+  g_return_val_if_fail (n_bits == 16 || n_bits == 8, EINVAL);
+  g_return_val_if_fail (n_channels >= 1, EINVAL);
+
+  data_length = dhandle->setup.n_values * (n_bits == 16 ? 2 : 1);
+  file_length = data_length;
+  file_length += 4 + 4;				/* 'RIFF' header */
+  file_length += 4 + 4 + 2 + 2 + 4 + 4 + 2 + 2;	/* 'fmt ' header */
+  file_length += 4 + 4;				/* 'data' header */
+  byte_per_sample = (n_bits == 16 ? 2 : 1) * n_channels;
+  byte_per_second = byte_per_sample * sample_freq;
+
+  errno = 0;
+  write_bytes (fd, 4, "RIFF");		/* main_chunk */
+  write_uint32_le (fd, file_length);
+  write_bytes (fd, 4, "WAVE");		/* chunk_type */
+  write_bytes (fd, 4, "fmt ");		/* sub_chunk */
+  write_uint32_le (fd, 16);		/* sub chunk length */
+  write_uint16_le (fd, 1);		/* format (1=PCM) */
+  write_uint16_le (fd, n_channels);
+  write_uint32_le (fd, sample_freq);
+  write_uint32_le (fd, byte_per_second);
+  write_uint16_le (fd, byte_per_sample);
+  write_uint16_le (fd, n_bits);
+  write_bytes (fd, 4, "data");		/* data chunk */
+  write_uint32_le (fd, data_length);
+
+  if (errno)
+    return errno;
+
+  return gsl_data_handle_dump (dhandle, fd,
+			       n_bits == 16 ? GSL_WAVE_FORMAT_SIGNED_16 : GSL_WAVE_FORMAT_UNSIGNED_8,
+			       G_LITTLE_ENDIAN);
+}
+
+gboolean
+gsl_data_detect_signal (GslDataHandle *handle,
+			GslLong       *sigstart_p,
+			GslLong       *sigend_p)
+{
+  gfloat level_0, level_1, level_2, level_3, level_4;
+  gfloat signal_threshold = 16. * 16. * 16.;	/* noise level threshold */
+  GslLong k, xcheck = -1, minsamp = -1, maxsamp = -2;
+  GslDataPeekBuffer peek_buffer = { +1 /* incremental direction */, 0, };
+  
+  g_return_val_if_fail (handle != NULL, FALSE);
+  g_return_val_if_fail (GSL_DATA_HANDLE_OPENED (handle), FALSE);
+  g_return_val_if_fail (sigstart_p || sigend_p, FALSE);
+
+  /* keep open */
+  gsl_data_handle_open (handle);
+
+  /* find fadein/fadeout point */
+  k = 0;
+  level_4 = gsl_data_handle_peek_value (handle, k, &peek_buffer);
+  level_4 *= 32768;
+  level_0 = level_1 = level_2 = level_3 = level_4;
+  for (; k < handle->setup.n_values; k++)
+    {
+      gfloat mean, needx, current;
+
+      current = gsl_data_handle_peek_value (handle, k, &peek_buffer) * 32768.;
+      if (xcheck < 0 && ABS (current) >= 16)
+	xcheck = k;
+      mean = (level_0 + level_1 + level_2 + level_3 + level_4) / 5;
+      needx = (ABS (level_4 + current - (level_0 + level_1 + level_2 + level_3) / 2) *
+	       ABS (level_4 - mean) * ABS (current - mean));
+      /* shift */
+      level_0 = level_1; level_1 = level_2; level_2 = level_3; level_3 = level_4; level_4 = current;
+      /* aprox. noise compare */
+      if (ABS (needx) > signal_threshold)
+	{
+	  if (minsamp < 0)
+	    minsamp = k;
+	  if (maxsamp < k)
+	    maxsamp = k;
+	}
+      /* if (minsamp >= 0 && xcheck >= 0)
+       *   break;
+       */
+    }
+  if (xcheck - minsamp > 0)
+    g_printerr("###################");
+  g_printerr ("active area %ld .. %ld, signal>16 at: %ld\t diff: %ld\n",minsamp,maxsamp,xcheck, xcheck-minsamp);
+
+  /* release open reference */
+  gsl_data_handle_close (handle);
+
+  if (sigstart_p)
+    *sigstart_p = minsamp;
+  if (sigend_p)
+    *sigend_p = MAX (-1, maxsamp);
+
+  return maxsamp >= minsamp;
+}
+
+GslLong
+gsl_data_find_sample (GslDataHandle *dhandle,
+		      gfloat         min_value,
+		      gfloat         max_value,
+		      GslLong        start_offset,
+		      gint           direction)
+{
+  GslDataPeekBuffer peekbuf = { 0, 0, 0, };
+  GslLong i;
+
+  g_return_val_if_fail (dhandle != NULL, -1);
+  g_return_val_if_fail (direction == -1 || direction == +1, -1);
+
+  if (gsl_data_handle_open (dhandle) != GSL_ERROR_NONE ||
+      start_offset >= dhandle->setup.n_values)
+    return -1;
+
+  if (start_offset < 0)
+    start_offset = dhandle->setup.n_values - 1;
+
+  peekbuf.dir = direction;
+  if (min_value <= max_value)
+    for (i = start_offset; i < dhandle->setup.n_values && i >= 0; i += direction)
+      {
+	gfloat val = gsl_data_handle_peek_value (dhandle, i, &peekbuf);
+
+	/* g_print ("(%lu): %f <= %f <= %f\n", i, min_value, val, max_value); */
+	if (val >= min_value && val <= max_value)
+	  break;
+      }
+  else
+    for (i = start_offset; i < dhandle->setup.n_values && i >= 0; i += direction)
+      {
+	gfloat val = gsl_data_handle_peek_value (dhandle, i, &peekbuf);
+
+	/* g_print ("(%lu): %f > %f || %f < %f\n", i, val, max_value, val, min_value); */
+	if (val > min_value || val < max_value)
+	  break;
+      }
+
+  gsl_data_handle_close (dhandle);
+
+  return i >= dhandle->setup.n_values ? -1: i;
+}
+
+static inline gdouble
+tailmatch_score_loop (GslDataHandle *shandle,
+		      GslDataHandle *dhandle,
+		      GslLong	   start,
+		      gdouble	   worst_score)
+{
+  GslLong l, length = MIN (shandle->setup.n_values, dhandle->setup.n_values);
+  gfloat v1[GSL_DATA_HANDLE_PEEK_BUFFER], v2[GSL_DATA_HANDLE_PEEK_BUFFER];
+  gdouble score = 0;
+
+  g_assert (start < length);
+
+  for (l = start; l < length; )
+    {
+      GslLong b = MIN (GSL_DATA_HANDLE_PEEK_BUFFER, length - l);
+
+      b = gsl_data_handle_read (shandle, l, b, v1);
+      b = gsl_data_handle_read (dhandle, l, b, v2);
+      g_assert (b >= 1);
+      l += b;
+
+      while (b--)
+	score += (v1[b] - v2[b]) * (v1[b] - v2[b]);
+
+      /* for performance, prematurely abort */
+      if (score > worst_score)
+	break;
+    }
+  return score;
+}
+
+gboolean
+gsl_data_find_tailmatch (GslDataHandle     *dhandle,
+			 const GslLoopSpec *lspec,
+			 GslLong           *loop_start_p,
+			 GslLong           *loop_end_p)
+{
+  GslDataHandle *shandle;
+  GslDataCache *dcache;
+  GslLong length, offset, l, lsize, pcount, start = 0, end = 0;
+  gdouble pbound, pval, best_score = GSL_MAXLONG;
+  
+  g_return_val_if_fail (dhandle != NULL, FALSE);
+  g_return_val_if_fail (lspec != NULL, FALSE);
+  g_return_val_if_fail (loop_start_p != NULL, FALSE);
+  g_return_val_if_fail (loop_end_p != NULL, FALSE);
+  g_return_val_if_fail (lspec->head_skip >= 0, FALSE);
+  g_return_val_if_fail (lspec->tail_cut >= 0, FALSE);
+  g_return_val_if_fail (lspec->min_loop >= 1, FALSE);
+  g_return_val_if_fail (lspec->max_loop >= lspec->min_loop, FALSE);
+  g_return_val_if_fail (lspec->tail_cut >= lspec->max_loop, FALSE);
+
+  if (gsl_data_handle_open (dhandle) != GSL_ERROR_NONE)
+    return FALSE;
+  length = dhandle->setup.n_values;
+  if (lspec->head_skip < length)
+    {
+      gsl_data_handle_close (dhandle);
+      return FALSE;
+    }
+  offset = lspec->head_skip;
+  length -= offset;
+  if (lspec->tail_cut < length)
+    {
+      gsl_data_handle_close (dhandle);
+      return FALSE;
+    }
+  length -= lspec->tail_cut;
+  if (lspec->max_loop <= length)
+    {
+      gsl_data_handle_close (dhandle);
+      return FALSE;
+    }
+  
+  dcache = gsl_data_cache_new (dhandle, 1);
+  shandle = gsl_data_handle_new_dcached (dcache);
+  gsl_data_cache_unref (dcache);
+  gsl_data_handle_open (shandle);
+  gsl_data_handle_close (dhandle);
+  gsl_data_handle_unref (shandle);
+  /* at this point, we just hold one open() count on shandle */
+  
+  pbound = (lspec->max_loop - lspec->min_loop + 1.);
+  pbound *= length / 100.;
+  pval = 0;
+  pcount = 100;
+
+  for (lsize = lspec->min_loop; lsize <= lspec->max_loop; lsize++)
+    {
+      for (l = length - lsize; l >= 0; l--)
+	{
+	  GslDataHandle *lhandle = gsl_data_handle_new_looped (shandle, offset + l, offset + l + lsize - 1);
+	  gdouble score;
+	  
+	  gsl_data_handle_open (lhandle);
+	  score = tailmatch_score_loop (shandle, lhandle, offset + l, best_score);
+	  gsl_data_handle_close (lhandle);
+	  gsl_data_handle_unref (lhandle);
+	  
+	  if (score < best_score)
+	    {
+	      start = offset + l;
+	      end = offset + l + lsize - 1;
+	      g_print ("\nimproved: %f < %f: [0x%lx..0x%lx] (%lu)\n", score, best_score, start, end, lsize);
+	      best_score = score;
+	    }
+	  else
+	    break;
+	}
+      if (!pcount--)
+	{
+	  pcount = 100;
+	  pval = lsize - lspec->min_loop;
+	  pbound = (lspec->max_loop - lspec->min_loop + 1.);
+	  g_print ("\rprocessed: %f%%                  \r", pval / pbound);
+	}
+    }
+  gsl_data_handle_close (shandle);
+
+  g_print ("\nhalted: %f: [0x%lx..0x%lx] (%lu)\n", best_score, start, end, end - start + 1);
+  
+  *loop_start_p = start;
+  *loop_end_p = end;
+
+  return TRUE;
+}
+
+/**
+ * gsl_data_find_block
+ * @handle:   an open GslDataHandle
+ * @n_values: amount of values to look for
+ * @values:   values to find
+ * @epsilon:  maximum difference upon comparisons
+ * @RETURNS:  position of values in data handle or -1
+ *
+ * Find the position of a block of values within a
+ * data handle, where all values compare to the reference
+ * values with a delta smaller than epsilon.
+ */
+GslLong
+gsl_data_find_block (GslDataHandle *handle,
+		     guint          n_values,
+		     const gfloat  *values,
+		     gfloat         epsilon)
+{
+  GslDataPeekBuffer pbuf = { +1 /* random access: 0 */ };
+  guint i;
+
+  g_return_val_if_fail (handle != NULL, -1);
+  g_return_val_if_fail (GSL_DATA_HANDLE_OPENED (handle), -1);
+
+  if (n_values < 1)
+    return -1;
+  else
+    g_return_val_if_fail (values != NULL, -1);
+
+  for (i = 0; i < handle->setup.n_values; i++)
+    {
+      guint j;
+
+      if (n_values > handle->setup.n_values - i)
+	return -1;
+
+      for (j = 0; j < n_values; j++)
+	{
+	  if (fabs (values[j] - gsl_data_handle_peek_value (handle, i + j, &pbuf)) >= epsilon)
+	    break;
+	}
+      if (j >= n_values)
+	return i;
+    }
+  return -1;
+}
+
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gsldatautils.h b/flow/gsl/gsldatautils.h
new file mode 100644
index 0000000..0dea8c9
--- /dev/null
+++ b/flow/gsl/gsldatautils.h
@@ -0,0 +1,909 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Stefan Westerfeld and Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_DATA_UTILS_H__
+#define __GSL_DATA_UTILS_H__
+
+#include <gsl/gslmath.h>
+#include <gsl/gsldatahandle.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- structures --- */
+#define GSL_DATA_HANDLE_PEEK_BUFFER     (8192)
+typedef struct
+{
+  gint    dir;   /* initialize direction to -1 or +1 (or 0 for random access) */
+  GslLong start; /* initialize to 0 */
+  GslLong end;   /* initialize to 0 */
+  gfloat  data[GSL_DATA_HANDLE_PEEK_BUFFER];
+} GslDataPeekBuffer;
+typedef struct
+{
+  GslLong head_skip;	/* FIXME: remove this */
+  GslLong tail_cut;
+  GslLong min_loop;
+  GslLong max_loop;
+} GslLoopSpec;	/* rename this to ...Data... */
+
+
+/* --- data utils --- */
+gboolean	gsl_data_detect_signal		(GslDataHandle		*handle,
+						 GslLong		*sigstart,
+						 GslLong		*sigend);
+GslLong		gsl_data_find_sample		(GslDataHandle		*dhandle,
+						 gfloat			 min_value,
+						 gfloat			 max_value,
+						 GslLong		 start_offset,
+						 gint			 direction);
+gboolean	gsl_data_find_tailmatch		(GslDataHandle		*dhandle,
+						 const GslLoopSpec	*lspec,
+						 GslLong		*loop_start_p,
+						 GslLong		*loop_end_p);
+GslLong		gsl_data_find_block		(GslDataHandle		*handle,
+						 guint			 n_values,
+						 const gfloat		*values,
+						 gfloat			 epsilon);
+
+
+/* --- data handle utils --- */
+static inline gfloat gsl_data_handle_peek_value	(GslDataHandle		*dhandle,
+						 GslLong		 position,
+						 GslDataPeekBuffer	*peekbuf);
+gint /* errno */     gsl_data_handle_dump	(GslDataHandle		*dhandle,
+						 gint			 fd,
+						 GslWaveFormatType	 format,
+						 guint			 byte_order);
+gint /* errno */     gsl_data_handle_dump_wav	(GslDataHandle		*dhandle,
+						 gint			 fd,
+						 guint			 n_bits,
+						 guint			 n_channels,
+						 guint			 sample_freq);
+
+
+/* --- conversion utils --- */
+static inline guint   gsl_conv_from_float	(GslWaveFormatType format,
+						 guint             byte_order,
+						 const gfloat     *src,
+						 gpointer          dest,
+						 guint             n_values);
+static inline guint   gsl_conv_from_float_clip	(GslWaveFormatType format,
+						 guint             byte_order,
+						 const gfloat     *src,
+						 gpointer          dest,
+						 guint             n_values);
+static inline void    gsl_conv_to_float		(GslWaveFormatType format,
+						 guint             byte_order,
+						 gconstpointer     src,
+						 gfloat           *dest,
+						 guint             n_values);
+static inline guint   gsl_conv_from_double	(GslWaveFormatType format,
+						 guint             byte_order,
+						 const gdouble    *src,
+						 gpointer          dest,
+						 guint             n_values);
+static inline guint   gsl_conv_from_double_clip	(GslWaveFormatType format,
+						 guint             byte_order,
+						 const gdouble    *src,
+						 gpointer          dest,
+						 guint             n_values);
+static inline void    gsl_conv_to_double	(GslWaveFormatType format,
+						 guint             byte_order,
+						 gconstpointer     src,
+						 gdouble          *dest,
+						 guint             n_values);
+
+
+
+/* --- misc implementations --- */
+gfloat  gsl_data_peek_value_f   (GslDataHandle     *dhandle,
+				 GslLong            pos,
+				 GslDataPeekBuffer *peekbuf);
+
+static inline gfloat
+gsl_data_handle_peek_value (GslDataHandle     *dhandle,
+			    GslLong	       position,
+			    GslDataPeekBuffer *peekbuf)
+{
+  return (position >= peekbuf->start && position < peekbuf->end ?
+	  peekbuf->data[position - peekbuf->start] :
+	  gsl_data_peek_value_f (dhandle, position, peekbuf));
+}
+
+#define	GSL_CONV_FORMAT(format, endian_flag)	(((endian_flag) << 16) | ((format) & 0xffff))
+
+static inline guint     /* returns number of bytes used in dest */
+gsl_conv_from_float (GslWaveFormatType format,
+                     guint             byte_order,
+                     const gfloat     *src,
+                     gpointer          dest,
+                     guint             n_values)
+{
+  gint8 *i8 = (gint8*) dest;
+  guint8 *u8 = (guint8*) dest;
+  gint16 *i16 = (gint16*) dest;
+  guint16 *u16 = (guint16*) dest;
+  guint32 *u32dest = (guint32*) dest;
+  const gfloat *bound = src + n_values;
+  guint32 *u32src = (guint32*) src, *u32bound = (guint32*) bound;
+  
+  if (!n_values)
+    return 0;
+  
+  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
+    {
+      GslFpuState fpu;
+      gfloat v;
+      gint16 vi16;
+      guint16 vu16;
+      guint32 vu32;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        *u8++ = *src++ * 128. + 128.5;
+      while (src < bound);
+      return n_values;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 128.;
+          *i8++ = gsl_ftoi (v);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *u16++ = *src++ * 2048. + 2048.5;
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu16 = *src++ * 2048. + 2048.5;
+          *u16++ = GUINT16_SWAP_LE_BE (vu16);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 2048.;
+          *i16++ = gsl_ftoi (v);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 2048.;
+          vi16 = gsl_ftoi (v);
+          *i16++ = GUINT16_SWAP_LE_BE (vi16);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *u16++ = *src++ * 32768. + 32768.5;
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu16 = *src++ * 32768. + 32768.5;
+          *u16++ = GUINT16_SWAP_LE_BE (vu16);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+	  v *= 32768.;
+          *i16++ = gsl_ftoi (v);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 32768.;
+          vi16 = gsl_ftoi (v);
+          *i16++ = GUINT16_SWAP_LE_BE (vi16);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
+      return n_values << 2;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu32 = *u32src++;
+          *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
+        }
+      while (u32src < u32bound);
+      return n_values << 2;
+    default:
+      g_assert_not_reached ();
+      return 0;
+    }
+}
+
+static inline guint     /* returns number of bytes used in dest */
+gsl_conv_from_float_clip (GslWaveFormatType format,
+                          guint             byte_order,
+                          const gfloat     *src,
+                          gpointer          dest,
+                          guint             n_values)
+{
+  gint8 *i8 = (gint8*) dest;
+  guint8 *u8 = (guint8*) dest;
+  gint16 *i16 = (gint16*) dest;
+  guint16 *u16 = (guint16*) dest;
+  guint32 *u32dest = (guint32*) dest;
+  const gfloat *bound = src + n_values;
+  guint32 *u32src = (guint32*) src, *u32bound = (guint32*) bound;
+  
+  if (!n_values)
+    return 0;
+  
+  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
+    {
+      GslFpuState fpu;
+      gfloat v;
+      guint32 vu32;
+      gint32 vi32;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 128. + 128.5;
+          *u8++ = CLAMP (vi32, 0, 255);
+        }
+      while (src < bound);
+      return n_values;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 128.;
+          vi32 = gsl_ftoi (v);
+          *i8++ = CLAMP (vi32, -128, 127);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 2048. + 2048.5;
+          *u16++ = CLAMP (vi32, 0, 4095);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 2048. + 2048.5;
+          vi32 = CLAMP (vi32, 0, 4095);
+          *u16++ = GUINT16_SWAP_LE_BE (vi32);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 2048.;
+          vi32 = gsl_ftoi (v);
+          *i16++ = CLAMP (vi32, -2048, 2047);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 2048.;
+          vi32 = gsl_ftoi (v);
+          vi32 = CLAMP (vi32, -2048, 2047);
+          *i16++ = GUINT16_SWAP_LE_BE (vi32);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 32768. + 32768.5;
+          *u16++ = CLAMP (vi32, 0, 65535);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 32768. + 32768.5;
+          vi32 = CLAMP (vi32, 0, 65535);
+          *u16++ = GUINT16_SWAP_LE_BE (vi32);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 32768.;
+          vi32 = gsl_ftoi (v);
+          vi32 = CLAMP (vi32, -32768, 32767);
+          *i16++ = vi32;
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 32768.;
+          vi32 = gsl_ftoi (v);
+          vi32 = CLAMP (vi32, -32768, 32767);
+          *i16++ = GUINT16_SWAP_LE_BE (vi32);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
+      return n_values << 2;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu32 = *u32src++;
+          *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
+        }
+      while (u32src < u32bound);
+      return n_values << 2;
+    default:
+      g_assert_not_reached ();
+      return 0;
+    }
+}
+
+static inline void
+gsl_conv_to_float (GslWaveFormatType format,
+                   guint             byte_order,
+                   gconstpointer     src,
+                   gfloat           *dest,
+                   guint             n_values)
+{
+  guint8 *u8 = (guint8*) src;
+  gint8 *i8 = (gint8*) src;
+  guint16 *u16 = (guint16*) src;
+  gint16 *i16 = (gint16*) src;
+  guint32 *u32src = (guint32*) src;
+  gfloat *bound = dest + n_values;
+  guint32 *u32dest = (guint32*) dest, *u32bound = (guint32*) bound;
+  
+  if (!n_values)
+    return;
+  
+  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
+    {
+      gint16 vi16;
+      guint16 vu16;
+      guint32 vu32;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        *dest++ = (*u8++ - 128) * (1. / 128.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        *dest++ = *i8++ * (1. / 128.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *dest++ = ((*u16++ & 0x0fff) - 2048) * (1. / 2048.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu16 = *u16++;
+          *dest++ = ((GUINT16_SWAP_LE_BE (vu16) & 0x0fff) - 2048) * (1. / 2048.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        {
+          vi16 = *i16++;
+          *dest++ = CLAMP (vi16, -2048, 2048) * (1. / 2048.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi16 = *i16++;
+          vi16 = GUINT16_SWAP_LE_BE (vi16);
+          *dest++ = CLAMP (vi16, -2048, 2048) * (1. / 2048.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *dest++ = (*u16++ - 32768) * (1. / 32768.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu16 = *u16++;
+          *dest++ = (GUINT16_SWAP_LE_BE (vu16) - 32768) * (1. / 32768.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *dest++ = *i16++ * (1. / 32768.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi16 = *i16++;
+          *dest++ = GUINT16_SWAP_LE_BE (vi16) * (1. / 32768.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu32 = *u32src++;
+          *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
+        }
+      while (u32dest < u32bound);
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+/* same as above with s/float/double */
+static inline guint     /* returns number of bytes used in dest */
+gsl_conv_from_double (GslWaveFormatType format,
+                      guint             byte_order,
+                      const gdouble    *src,
+                      gpointer          dest,
+                      guint             n_values)
+{
+  gint8 *i8 = (gint8*) dest;
+  guint8 *u8 = (guint8*) dest;
+  gint16 *i16 = (gint16*) dest;
+  guint16 *u16 = (guint16*) dest;
+  guint32 *u32dest = (guint32*) dest;
+  const gdouble *bound = src + n_values;
+  guint32 *u32src = (guint32*) src, *u32bound = (guint32*) bound;
+  
+  if (!n_values)
+    return 0;
+  
+  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
+    {
+      GslFpuState fpu;
+      gdouble v;
+      gint16 vi16;
+      guint16 vu16;
+      guint32 vu32;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        *u8++ = *src++ * 128. + 128.5;
+      while (src < bound);
+      return n_values;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 128.;
+          *i8++ = gsl_ftoi (v);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *u16++ = *src++ * 2048. + 2048.5;
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu16 = *src++ * 2048. + 2048.5;
+          *u16++ = GUINT16_SWAP_LE_BE (vu16);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 2048.;
+          *i16++ = gsl_ftoi (v);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 2048.;
+          vi16 = gsl_ftoi (v);
+          *i16++ = GUINT16_SWAP_LE_BE (vi16);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *u16++ = *src++ * 32768. + 32768.5;
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu16 = *src++ * 32768. + 32768.5;
+          *u16++ = GUINT16_SWAP_LE_BE (vu16);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 32768.;
+          *i16++ = gsl_ftoi (v);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 32768.;
+          vi16 = gsl_ftoi (v);
+          *i16++ = GUINT16_SWAP_LE_BE (vi16);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
+      return n_values << 2;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu32 = *u32src++;
+          *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
+        }
+      while (u32src < u32bound);
+      return n_values << 2;
+    default:
+      g_assert_not_reached ();
+      return 0;
+    }
+}
+
+static inline guint     /* returns number of bytes used in dest */
+gsl_conv_from_double_clip (GslWaveFormatType format,
+			   guint             byte_order,
+			   const gdouble    *src,
+			   gpointer          dest,
+			   guint             n_values)
+{
+  gint8 *i8 = (gint8*) dest;
+  guint8 *u8 = (guint8*) dest;
+  gint16 *i16 = (gint16*) dest;
+  guint16 *u16 = (guint16*) dest;
+  guint32 *u32dest = (guint32*) dest;
+  const gdouble *bound = src + n_values;
+  guint32 *u32src = (guint32*) src, *u32bound = (guint32*) bound;
+  
+  if (!n_values)
+    return 0;
+  
+  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
+    {
+      GslFpuState fpu;
+      gdouble v;
+      guint32 vu32;
+      gint32 vi32;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 128. + 128.5;
+          *u8++ = CLAMP (vi32, 0, 255);
+        }
+      while (src < bound);
+      return n_values;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 128.;
+          vi32 = gsl_ftoi (v);
+          *i8++ = CLAMP (vi32, -128, 127);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 2048. + 2048.5;
+          *u16++ = CLAMP (vi32, 0, 4095);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 2048. + 2048.5;
+          vi32 = CLAMP (vi32, 0, 4095);
+          *u16++ = GUINT16_SWAP_LE_BE (vi32);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 2048.;
+          vi32 = gsl_ftoi (v);
+          *i16++ = CLAMP (vi32, -2048, 2047);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 2048.;
+          vi32 = gsl_ftoi (v);
+          vi32 = CLAMP (vi32, -2048, 2047);
+          *i16++ = GUINT16_SWAP_LE_BE (vi32);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 32768. + 32768.5;
+          *u16++ = CLAMP (vi32, 0, 65535);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi32 = *src++ * 32768. + 32768.5;
+          vi32 = CLAMP (vi32, 0, 65535);
+          *u16++ = GUINT16_SWAP_LE_BE (vi32);
+        }
+      while (src < bound);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 32768.;
+          vi32 = gsl_ftoi (v);
+          vi32 = CLAMP (vi32, -32768, 32767);
+          *i16++ = vi32;
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      gsl_fpu_setround (&fpu);
+      do
+        {
+          v = *src++;
+          v *= 32768.;
+          vi32 = gsl_ftoi (v);
+          vi32 = CLAMP (vi32, -32768, 32767);
+          *i16++ = GUINT16_SWAP_LE_BE (vi32);
+        }
+      while (src < bound);
+      gsl_fpu_restore (fpu);
+      return n_values << 1;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
+      return n_values << 2;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu32 = *u32src++;
+          *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
+        }
+      while (u32src < u32bound);
+      return n_values << 2;
+    default:
+      g_assert_not_reached ();
+      return 0;
+    }
+}
+
+static inline void
+gsl_conv_to_double (GslWaveFormatType format,
+		    guint             byte_order,
+		    gconstpointer     src,
+		    gdouble          *dest,
+		    guint             n_values)
+{
+  guint8 *u8 = (guint8*) src;
+  gint8 *i8 = (gint8*) src;
+  guint16 *u16 = (guint16*) src;
+  gint16 *i16 = (gint16*) src;
+  guint32 *u32src = (guint32*) src;
+  gdouble *bound = dest + n_values;
+  guint32 *u32dest = (guint32*) dest, *u32bound = (guint32*) bound;
+  
+  if (!n_values)
+    return;
+  
+  switch (GSL_CONV_FORMAT (format, byte_order == G_BYTE_ORDER))
+    {
+      gint16 vi16;
+      guint16 vu16;
+      guint32 vu32;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        *dest++ = (*u8++ - 128) * (1. / 128.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER == G_BYTE_ORDER):
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_8, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        *dest++ = *i8++ * (1. / 128.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *dest++ = ((*u16++ & 0x0fff) - 2048) * (1. / 2048.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu16 = *u16++;
+          *dest++ = ((GUINT16_SWAP_LE_BE (vu16) & 0x0fff) - 2048) * (1. / 2048.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        {
+          vi16 = *i16++;
+          *dest++ = CLAMP (vi16, -2048, 2048) * (1. / 2048.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_12, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi16 = *i16++;
+          vi16 = GUINT16_SWAP_LE_BE (vi16);
+          *dest++ = CLAMP (vi16, -2048, 2048) * (1. / 2048.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *dest++ = (*u16++ - 32768) * (1. / 32768.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_UNSIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu16 = *u16++;
+          *dest++ = (GUINT16_SWAP_LE_BE (vu16) - 32768) * (1. / 32768.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER == G_BYTE_ORDER):
+      do
+        *dest++ = *i16++ * (1. / 32768.);
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_SIGNED_16, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vi16 = *i16++;
+          *dest++ = GUINT16_SWAP_LE_BE (vi16) * (1. / 32768.);
+        }
+      while (dest < bound);
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER == G_BYTE_ORDER):
+      break;
+    case GSL_CONV_FORMAT (GSL_WAVE_FORMAT_FLOAT, G_BYTE_ORDER != G_BYTE_ORDER):
+      do
+        {
+          vu32 = *u32src++;
+          *u32dest++ = GUINT32_SWAP_LE_BE (vu32);
+        }
+      while (u32dest < u32bound);
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_DATA_UTILS_H__ */
+
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gsldefs.h b/flow/gsl/gsldefs.h
new file mode 100644
index 0000000..d610e9c
--- /dev/null
+++ b/flow/gsl/gsldefs.h
@@ -0,0 +1,136 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Stefan Westerfeld and Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_DEFS_H__
+#define __GSL_DEFS_H__
+
+/* configure checks */
+#include <gsl/gslconfig.h>
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- forward decls --- */
+typedef struct _GslMagic		GslMagic;
+typedef struct _GslClass		GslClass;
+typedef struct _GslComplex		GslComplex;
+typedef struct _GslDataCache		GslDataCache;
+typedef struct _GslDataHandle		GslDataHandle;
+typedef struct _GslDataHandleFuncs	GslDataHandleFuncs;
+typedef struct _GslGlueContext          GslGlueContext;
+typedef struct _GslJob			GslJob;
+typedef struct _GslModule		GslModule;
+typedef struct _GslIStream		GslIStream;
+typedef struct _GslJStream		GslJStream;
+typedef struct _GslLoader		GslLoader;
+typedef struct _GslOStream		GslOStream;
+typedef struct _GslThread		GslThread;
+typedef struct _GslTrans		GslTrans;
+typedef struct _GslWaveChunk		GslWaveChunk;
+typedef struct _GslWaveChunkBlock	GslWaveChunkBlock;
+typedef struct _GslRecMutex		GslRecMutex;
+typedef struct _GslRing			GslRing;
+typedef union _GslCond			GslCond;
+typedef union _GslMutex			GslMutex;
+/* ssize_t/off_t type used within Gsl */
+typedef glong			  GslLong;
+#define	GSL_MAXLONG		  G_MAXLONG
+
+
+/* --- GSL errors --- */
+typedef enum    /*< skip >*/
+{
+  GSL_ERROR_NONE,
+  GSL_ERROR_INTERNAL,
+  GSL_ERROR_UNKNOWN,
+  /* I/O errors */
+  GSL_ERROR_IO,
+  GSL_ERROR_PERMS,
+  GSL_ERROR_BUSY,
+  GSL_ERROR_EXISTS,
+  GSL_ERROR_TEMP,
+  GSL_ERROR_EOF,
+#define GSL_ERROR_FILE_EMPTY	GSL_ERROR_EOF
+  GSL_ERROR_NOT_FOUND,
+  GSL_ERROR_OPEN_FAILED,
+  GSL_ERROR_SEEK_FAILED,
+  GSL_ERROR_READ_FAILED,
+  GSL_ERROR_WRITE_FAILED,
+  /* content errors */
+  GSL_ERROR_FORMAT_INVALID,
+  GSL_ERROR_FORMAT_UNKNOWN,
+  GSL_ERROR_DATA_CORRUPT,
+  GSL_ERROR_CONTENT_GLITCH,
+  /* miscellaneous errors */
+  GSL_ERROR_NO_RESOURCE,
+  GSL_ERROR_CODEC_FAILURE,
+  GSL_ERROR_LAST        /* administrative */
+} GslErrorType;
+
+
+/* --- functions --- */
+typedef void     (*GslAccessFunc)       (GslModule      *module,
+					 gpointer        data);
+typedef void     (*GslFreeFunc)         (gpointer        data);
+typedef void     (*GslModuleFreeFunc)   (gpointer        data,
+					 const GslClass	*klass);
+
+
+#if defined (BSE_COMPILATION) || defined (BSE_PLUGIN_FALLBACK) \
+    || (GSL_USE_GSL_GLIB) || defined (GSL_EXTENSIONS)
+#  define if_expect(cond)		if (GSL_GCC_EXPECT (cond))
+#  define if_reject(cond)		if (GSL_GCC_REJECT (cond))
+#endif
+
+
+/* --- implementation details --- */
+#define	GSL_ENGINE_MAX_POLLFDS	(128)
+union _GslCond
+{
+  gpointer cond_pointer;
+  guint8   cond_dummy[MAX (8, GSL_SIZEOF_PTH_COND_T)];
+};
+union _GslMutex
+{
+  gpointer mutex_pointer;
+  guint8   mutex_dummy[MAX (8, GSL_SIZEOF_PTH_MUTEX_T)];
+};
+struct _GslRecMutex
+{
+  GslMutex sync_mutex;
+  gpointer owner;
+  guint    depth;
+};
+#if __GNUC__ >= 3 && defined __OPTIMIZE__
+#  define GSL_GCC_EXPECT(cond)	(__builtin_expect ((cond) != 0, 1))
+#  define GSL_GCC_REJECT(cond)	(__builtin_expect ((cond) != 0, 0))
+#else
+#  define GSL_GCC_EXPECT(cond)	cond
+#  define GSL_GCC_REJECT(cond)	cond
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_DEFS_H__ */
+
+/* vim:set ts=8 sw=2 sts=2: */
diff --git a/flow/gsl/gslengine.c b/flow/gsl/gslengine.c
new file mode 100644
index 0000000..65ee620
--- /dev/null
+++ b/flow/gsl/gslengine.c
@@ -0,0 +1,753 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslengine.h"
+
+#include "gslcommon.h"
+#include "gslopnode.h"
+#include "gslopmaster.h"
+
+
+/* --- prototypes --- */
+static void wakeup_master (void);
+
+
+/* --- UserThread --- */
+GslModule*
+gsl_module_new (const GslClass *klass,
+		gpointer        user_data)
+{
+  EngineNode *node;
+  guint i;
+
+  g_return_val_if_fail (klass != NULL, NULL);
+  g_return_val_if_fail (klass->process != NULL || klass->process_defer != NULL, NULL);
+  if (klass->process_defer)
+    {
+      g_warning ("%s: Delay cycle processing not yet implemented", G_STRLOC);
+      return NULL;
+    }
+
+  node = gsl_new_struct0 (EngineNode, 1);
+
+  /* setup GslModule */
+  node->module.klass = klass;
+  node->module.user_data = user_data;
+  node->module.istreams = klass->n_istreams ? gsl_new_struct0 (GslIStream, ENGINE_NODE_N_ISTREAMS (node)) : NULL;
+  node->module.jstreams = klass->n_jstreams ? gsl_new_struct0 (GslJStream, ENGINE_NODE_N_JSTREAMS (node)) : NULL;
+  node->module.ostreams = _engine_alloc_ostreams (ENGINE_NODE_N_OSTREAMS (node));
+
+  /* setup EngineNode */
+  node->inputs = ENGINE_NODE_N_ISTREAMS (node) ? gsl_new_struct0 (EngineInput, ENGINE_NODE_N_ISTREAMS (node)) : NULL;
+  node->jinputs = ENGINE_NODE_N_JSTREAMS (node) ? gsl_new_struct0 (EngineJInput*, ENGINE_NODE_N_JSTREAMS (node)) : NULL;
+  node->outputs = ENGINE_NODE_N_OSTREAMS (node) ? gsl_new_struct0 (EngineOutput, ENGINE_NODE_N_OSTREAMS (node)) : NULL;
+  node->output_nodes = NULL;
+  node->integrated = FALSE;
+  gsl_rec_mutex_init (&node->rec_mutex);
+  for (i = 0; i < ENGINE_NODE_N_OSTREAMS (node); i++)
+    {
+      node->outputs[i].buffer = node->module.ostreams[i].values;
+      node->module.ostreams[i].sub_sample_pattern = gsl_engine_sub_sample_test (node->module.ostreams[i].values);
+    }
+  node->flow_jobs = NULL;
+  node->fjob_first = NULL;
+  node->fjob_last = NULL;
+
+  return &node->module;
+}
+
+/**
+ * gsl_module_tick_stamp
+ * @module:  a GSL engine module
+ * @RETURNS: the module's tick stamp, indicating its process status
+ *
+ * Any thread may call this function on a valid engine module.
+ * The module specific tick stamp is updated to gsl_tick_stamp() +
+ * @n_values every time its GslProcessFunc() function was
+ * called. See also gsl_tick_stamp().
+ */
+guint64
+gsl_module_tick_stamp (GslModule *module)
+{
+  g_return_val_if_fail (module != NULL, 0);
+
+  return ENGINE_NODE (module)->counter;
+}
+
+/**
+ * gsl_job_integrate
+ * @module: The module to integrate
+ * @Returns: New job suitable for gsl_trans_add()
+ *
+ * Create a new transaction job to integrate @module into the engine.
+ */
+GslJob*
+gsl_job_integrate (GslModule *module)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (module != NULL, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_INTEGRATE;
+  job->data.node = ENGINE_NODE (module);
+
+  return job;
+}
+
+/**
+ * gsl_job_discard
+ * @module: The module to discard
+ * @Returns: New job suitable for gsl_trans_add()
+ *
+ * Create a new transaction job which removes @module from the
+ * engine and destroys it.
+ */
+GslJob*
+gsl_job_discard (GslModule *module)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (module != NULL, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_DISCARD;
+  job->data.node = ENGINE_NODE (module);
+
+  return job;
+}
+
+/**
+ * gsl_job_connect
+ * @src_module: Module with output stream
+ * @src_ostream: Index of output stream of @src_module
+ * @dest_module: Module with unconnected input stream
+ * @dest_istream: Index of input stream of @dest_module
+ * @Returns: New job suitable for gsl_trans_add()
+ *
+ * Create a new transaction job which connects the output stream @src_ostream
+ * of module @src_module to the input stream @dest_istream of module @dest_module
+ * (it is an error if the input stream is already connected by the time the job
+ * is executed).
+ */
+GslJob*
+gsl_job_connect (GslModule *src_module,
+		 guint      src_ostream,
+		 GslModule *dest_module,
+		 guint      dest_istream)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (src_module != NULL, NULL);
+  g_return_val_if_fail (src_ostream < src_module->klass->n_ostreams, NULL);
+  g_return_val_if_fail (dest_module != NULL, NULL);
+  g_return_val_if_fail (dest_istream < dest_module->klass->n_istreams, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_ICONNECT;
+  job->data.connection.dest_node = ENGINE_NODE (dest_module);
+  job->data.connection.dest_ijstream = dest_istream;
+  job->data.connection.src_node = ENGINE_NODE (src_module);
+  job->data.connection.src_ostream = src_ostream;
+
+  return job;
+}
+
+GslJob*
+gsl_job_jconnect (GslModule *src_module,
+		  guint      src_ostream,
+		  GslModule *dest_module,
+		  guint      dest_jstream)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (src_module != NULL, NULL);
+  g_return_val_if_fail (src_ostream < src_module->klass->n_ostreams, NULL);
+  g_return_val_if_fail (dest_module != NULL, NULL);
+  g_return_val_if_fail (dest_jstream < dest_module->klass->n_jstreams, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_JCONNECT;
+  job->data.connection.dest_node = ENGINE_NODE (dest_module);
+  job->data.connection.dest_ijstream = dest_jstream;
+  job->data.connection.src_node = ENGINE_NODE (src_module);
+  job->data.connection.src_ostream = src_ostream;
+
+  return job;
+}
+
+/**
+ * gsl_job_disconnect
+ * @dest_module: Module with connected input stream
+ * @dest_istream: Index of input stream of @dest_module
+ * @Returns: New job suitable for gsl_trans_add()
+ *
+ * Create a new transaction job which causes the input stream @dest_istream
+ * of @dest_module to be disconnected (it is an error if the input stream isn't
+ * connected by the time the job is executed).
+ */
+GslJob*
+gsl_job_disconnect (GslModule *dest_module,
+		    guint      dest_istream)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (dest_module != NULL, NULL);
+  g_return_val_if_fail (dest_istream < dest_module->klass->n_istreams, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_IDISCONNECT;
+  job->data.connection.dest_node = ENGINE_NODE (dest_module);
+  job->data.connection.dest_ijstream = dest_istream;
+  job->data.connection.src_node = NULL;
+  job->data.connection.src_ostream = ~0;
+
+  return job;
+}
+
+GslJob*
+gsl_job_jdisconnect (GslModule *dest_module,
+		     guint      dest_jstream,
+		     GslModule *src_module,
+		     guint	src_ostream)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (dest_module != NULL, NULL);
+  g_return_val_if_fail (dest_jstream < dest_module->klass->n_jstreams, NULL);
+  g_return_val_if_fail (src_module != NULL, NULL);
+  g_return_val_if_fail (src_ostream < src_module->klass->n_ostreams, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_JDISCONNECT;
+  job->data.connection.dest_node = ENGINE_NODE (dest_module);
+  job->data.connection.dest_ijstream = dest_jstream;
+  job->data.connection.src_node = ENGINE_NODE (src_module);
+  job->data.connection.src_ostream = src_ostream;
+
+  return job;
+}
+
+GslJob*
+gsl_job_set_consumer (GslModule *module,
+		      gboolean   is_toplevel_consumer)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (module != NULL, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = is_toplevel_consumer ? ENGINE_JOB_SET_CONSUMER : ENGINE_JOB_UNSET_CONSUMER;
+  job->data.node = ENGINE_NODE (module);
+
+  return job;
+}
+
+/**
+ * GslAccessFunc
+ * @module:	Module to operate on
+ * @data:	Accessor data
+ *
+ * The GslAccessFunc is a user supplied callback function which can access
+ * a module in times it is not processing. Accessors are usually used to
+ * either read out a module's current state, or to modify its state. An
+ * accessor may only operate on the @data and the @module passed
+ * in to it.
+ */
+/**
+ * gsl_job_access
+ * @module: The module to access
+ * @access_func: The accessor function
+ * @data: Data passed in to the accessor
+ * @free_func: Function to free @data
+ * @Returns: New job suitable for gsl_trans_add()
+ *
+ * Create a new transaction job which will invoke @access_func
+ * on @module with @data when the transaction queue is processed
+ * to modify the module's state.
+ */
+GslJob*
+gsl_job_access (GslModule    *module,
+		GslAccessFunc access_func,
+		gpointer      data,
+		GslFreeFunc   free_func)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (module != NULL, NULL);
+  g_return_val_if_fail (access_func != NULL, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_ACCESS;
+  job->data.access.node = ENGINE_NODE (module);
+  job->data.access.access_func = access_func;
+  job->data.access.data = data;
+  job->data.access.free_func = free_func;
+
+  return job;
+}
+
+/**
+ * gsl_flow_job_access
+ */
+GslJob*
+gsl_flow_job_access (GslModule    *module,
+		     guint64       tick_stamp,
+		     GslAccessFunc access_func,
+		     gpointer      data,
+		     GslFreeFunc   free_func)
+{
+  GslJob *job;
+  EngineFlowJob *fjob;
+
+  g_return_val_if_fail (module != NULL, NULL);
+  g_return_val_if_fail (access_func != NULL, NULL);
+
+  fjob = (EngineFlowJob*) gsl_new_struct0 (EngineFlowJobAccess, 1);
+  fjob->fjob_id = ENGINE_FLOW_JOB_ACCESS;
+  fjob->any.tick_stamp = tick_stamp;
+  fjob->access.access_func = access_func;
+  fjob->access.data = data;
+  fjob->access.free_func = free_func;
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_FLOW_JOB;
+  job->data.flow_job.node = ENGINE_NODE (module);
+  job->data.flow_job.fjob = fjob;
+
+  return job;
+}
+
+GslJob*
+gsl_flow_job_suspend (GslModule *module,
+		      guint64    tick_stamp)
+{
+  GslJob *job;
+  EngineFlowJob *fjob;
+
+  g_return_val_if_fail (module != NULL, NULL);
+
+  fjob = (EngineFlowJob*) gsl_new_struct0 (EngineFlowJobAny, 1);
+  fjob->fjob_id = ENGINE_FLOW_JOB_SUSPEND;
+  fjob->any.tick_stamp = tick_stamp;
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_FLOW_JOB;
+  job->data.flow_job.node = ENGINE_NODE (module);
+  job->data.flow_job.fjob = fjob;
+
+  return job;
+}
+
+GslJob*
+gsl_flow_job_resume (GslModule *module,
+		     guint64    tick_stamp)
+{
+  GslJob *job;
+  EngineFlowJob *fjob;
+
+  g_return_val_if_fail (module != NULL, NULL);
+
+  fjob = (EngineFlowJob*) gsl_new_struct0 (EngineFlowJobAny, 1);
+  fjob->fjob_id = ENGINE_FLOW_JOB_RESUME;
+  fjob->any.tick_stamp = tick_stamp;
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_FLOW_JOB;
+  job->data.flow_job.node = ENGINE_NODE (module);
+  job->data.flow_job.fjob = fjob;
+
+  return job;
+}
+
+/**
+ * GslPollFunc
+ * @data: Data of poll function
+ * @n_values: Minimum number of values the engine wants to process
+ * @timeout_p: Location of timeout value
+ * @n_fds: Number of file descriptors used for polling
+ * @fds: File descriptors to be used for polling
+ * @revents_filled: Indicates whether @fds actually have their ->revents field filled with valid data.
+ * @Returns: A boolean value indicating whether the engine should process data right now
+ *
+ * The GslPollFunc is a user supplied callback function which can be hooked into the
+ * GSL engine. The engine uses the poll functions to determine whether processing of
+ * @n_values in its module network is necessary.
+ * In order for the poll functions to react to extern events, such as device driver
+ * status changes, the engine will poll(2) the @fds of the poll function and invoke
+ * the callback with @revents_filled==%TRUE if any of its @fds changed state.
+ * The callback may also be invoked at other random times with @revents_filled=%FALSE.
+ * It is supposed to return %TRUE if network processing is currently necessary, and
+ * %FALSE if not.
+ * If %FALSE is returned, @timeout_p may be filled with the number of milliseconds
+ * the engine should use for polling at maximum.
+ */
+/**
+ * gsl_job_add_poll
+ * @poll_func: Poll function to add
+ * @data: Data of poll function
+ * @free_func: Function to free @data
+ * @n_fds: Number of poll file descriptors
+ * @fds: File descriptors to select(2) or poll(2) on
+ * @Returns: New job suitable for gsl_trans_add()
+ *
+ * Create a new transaction job which adds a poll function
+ * to the engine. The poll function is used by the engine to
+ * determine whether processing is currently necessary.
+ */
+GslJob*
+gsl_job_add_poll (GslPollFunc    poll_func,
+		  gpointer       data,
+		  GslFreeFunc    free_func,
+		  guint          n_fds,
+		  const GPollFD *fds)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (poll_func != NULL, NULL);
+  if (n_fds)
+    g_return_val_if_fail (fds != NULL, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_ADD_POLL;
+  job->data.poll.poll_func = poll_func;
+  job->data.poll.data = data;
+  job->data.poll.n_fds = n_fds;
+  job->data.poll.fds = g_memdup (fds, sizeof (fds[0]) * n_fds);
+
+  return job;
+}
+
+/**
+ * gsl_job_remove_poll
+ * @poll_func: Poll function to remove
+ * @data: Data of poll function
+ * @Returns: New job suitable for gsl_trans_add()
+ *
+ * Create a new transaction job which removes a previously inserted poll
+ * function from the engine.
+ */
+GslJob*
+gsl_job_remove_poll (GslPollFunc poll_func,
+		     gpointer    data)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (poll_func != NULL, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_REMOVE_POLL;
+  job->data.poll.poll_func = poll_func;
+  job->data.poll.data = data;
+  job->data.poll.free_func = NULL;
+  job->data.poll.fds = NULL;
+
+  return job;
+}
+
+/**
+ * gsl_job_debug
+ * @debug: Debug message
+ * @Returns: New job suitable for gsl_trans_add()
+ *
+ * Create a new transaction job which issues @debug message when
+ * the job is executed. This function is meant for debugging purposes
+ * during development phase only and shouldn't be used in production code.
+ */
+GslJob*
+gsl_job_debug (const gchar *debug)
+{
+  GslJob *job;
+
+  g_return_val_if_fail (debug != NULL, NULL);
+
+  job = gsl_new_struct0 (GslJob, 1);
+  job->job_id = ENGINE_JOB_DEBUG;
+  job->data.debug = g_strdup (debug);
+
+  return job;
+}
+
+/**
+ * gsl_trans_open
+ * @Returns: Newly opened empty transaction
+ *
+ * Open up a new transaction to commit jobs to the GSL engine.
+ * This function may cause garbage collection (see
+ * gsl_engine_garbage_collect()).
+ */
+GslTrans*
+gsl_trans_open (void)
+{
+  GslTrans *trans;
+
+  gsl_engine_garbage_collect ();
+
+  trans = gsl_new_struct0 (GslTrans, 1);
+
+  trans->jobs_head = NULL;
+  trans->jobs_tail = NULL;
+  trans->comitted = FALSE;
+  trans->cqt_next = NULL;
+
+  return trans;
+}
+
+/**
+ * gsl_trans_add
+ * @trans: Opened transaction
+ * @job: Job to add
+ *
+ * Append a job to an opened transaction.
+ */
+void
+gsl_trans_add (GslTrans *trans,
+	       GslJob   *job)
+{
+  g_return_if_fail (trans != NULL);
+  g_return_if_fail (trans->comitted == FALSE);
+  g_return_if_fail (job != NULL);
+  g_return_if_fail (job->next == NULL);
+
+  if (trans->jobs_tail)
+    trans->jobs_tail->next = job;
+  else
+    trans->jobs_head = job;
+  trans->jobs_tail = job;
+}
+
+/**
+ * gsl_trans_commit
+ * @trans: Opened transaction
+ *
+ * Close the transaction and commit it to the engine. The engine
+ * will execute the jobs contained in this transaction as soon as
+ * it has completed its current processing cycle. The jobs will be
+ * executed in the exact order they were added to the transaction.
+ */
+void
+gsl_trans_commit (GslTrans *trans)
+{
+  g_return_if_fail (trans != NULL);
+  g_return_if_fail (trans->comitted == FALSE);
+  g_return_if_fail (trans->cqt_next == NULL);
+
+  if (trans->jobs_head)
+    {
+      trans->comitted = TRUE;
+      _engine_enqueue_trans (trans);
+      wakeup_master ();
+    }
+  else
+    gsl_trans_dismiss (trans);
+}
+
+/**
+ * gsl_trans_dismiss
+ * @trans: Opened transaction
+ *
+ * Close and discard the transaction, destroy all jobs currently
+ * contained in it and do not execute them.
+ * This function may cause garbage collection (see
+ * gsl_engine_garbage_collect()).
+ */
+void
+gsl_trans_dismiss (GslTrans *trans)
+{
+  g_return_if_fail (trans != NULL);
+  g_return_if_fail (trans->comitted == FALSE);
+  g_return_if_fail (trans->cqt_next == NULL);
+
+  _engine_free_trans (trans);
+
+  gsl_engine_garbage_collect ();
+}
+
+/**
+ * gsl_transact
+ * @job: First job
+ * @...: %NULL terminated job list
+ *
+ * Convenience function which openes up a new transaction,
+ * collects the %NULL terminated job list passed to the function,
+ * and commits the transaction.
+ */
+void
+gsl_transact (GslJob *job,
+	      ...)
+{
+  GslTrans *trans = gsl_trans_open ();
+  va_list var_args;
+
+  va_start (var_args, job);
+  while (job)
+    {
+      gsl_trans_add (trans, job);
+      job = va_arg (var_args, GslJob*);
+    }
+  va_end (var_args);
+  gsl_trans_commit (trans);
+}
+
+
+/* --- initialization --- */
+static void
+slave (gpointer data)
+{
+  gboolean run = TRUE;
+
+  while (run)
+    {
+      GslTrans *trans = gsl_trans_open ();
+      gchar *str = g_strdup_printf ("SLAVE(%p): idle", g_thread_self ());
+
+      gsl_trans_add (trans, gsl_job_debug (str));
+      g_free (str);
+      gsl_trans_add (trans, gsl_job_debug ("string2"));
+      gsl_trans_commit (trans);
+
+      trans = gsl_trans_open ();
+      gsl_trans_add (trans, gsl_job_debug ("trans2"));
+      gsl_trans_commit (trans);
+
+      g_usleep (1000*500);
+    }
+}
+
+/* --- setup & trigger --- */
+static gboolean   gsl_engine_initialized = FALSE;
+static gboolean   gsl_engine_threaded = FALSE;
+static GslThread *master_thread = NULL;
+guint		gsl_externvar_bsize = 0;
+guint		gsl_externvar_sample_freq = 0;
+guint		gsl_externvar_sub_sample_mask = 0;
+guint		gsl_externvar_sub_sample_steps = 0;
+
+/**
+ * gsl_engine_init
+ * @block_size: number of values to process block wise
+ *
+ * Initialize the GSL engine, this function must be called prior to
+ * any other engine related function and can only be invoked once.
+ * The @block_size determines the amount by which the global tick
+ * stamp (see gsl_tick_stamp()) is updated every time the whole
+ * module network completed processing @block_size values.
+ */
+void
+gsl_engine_init (gboolean run_threaded,
+		 guint	  block_size,
+		 guint	  sample_freq,
+		 guint    sub_sample_mask)
+{
+  g_return_if_fail (gsl_engine_initialized == FALSE);
+  g_return_if_fail (block_size > 0 && block_size <= GSL_STREAM_MAX_VALUES);
+  g_return_if_fail (sample_freq > 0);
+  g_return_if_fail (sub_sample_mask < block_size);
+  g_return_if_fail ((sub_sample_mask & (sub_sample_mask + 1)) == 0);	/* power of 2 */
+
+  gsl_engine_initialized = TRUE;
+  gsl_engine_threaded = run_threaded;
+  gsl_externvar_bsize = block_size;
+  gsl_externvar_sample_freq = sample_freq;
+  gsl_externvar_sub_sample_mask = sub_sample_mask << 2;	/* shift out sizeof (float) alignment */
+  gsl_externvar_sub_sample_steps = sub_sample_mask + 1;
+  _gsl_tick_stamp_set_leap (block_size);
+
+  ENG_DEBUG ("initialization: threaded=%s", gsl_engine_threaded ? "TRUE" : "FALSE");
+
+  if (gsl_engine_threaded)
+    {
+      if (!g_thread_supported ()) g_thread_init (NULL);
+      master_thread = gsl_thread_new (_engine_master_thread, NULL);
+      if (0)
+	gsl_thread_new (slave, NULL);
+    }
+}
+
+static void
+wakeup_master (void)
+{
+  if (master_thread)
+    gsl_thread_wakeup (master_thread);
+}
+
+gboolean
+gsl_engine_prepare (GslEngineLoop *loop)
+{
+  g_return_val_if_fail (loop != NULL, FALSE);
+  g_return_val_if_fail (gsl_engine_initialized == TRUE, FALSE);
+
+  if (!gsl_engine_threaded)
+    return _engine_master_prepare (loop);
+  else
+    {
+      loop->timeout = -1;
+      loop->fds_changed = FALSE;
+      loop->n_fds = 0;
+      loop->revents_filled = FALSE;
+      return FALSE;
+    }
+}
+
+gboolean
+gsl_engine_check (const GslEngineLoop *loop)
+{
+  g_return_val_if_fail (loop != NULL, FALSE);
+  if (loop->n_fds)
+    g_return_val_if_fail (loop->revents_filled == TRUE, FALSE);
+
+  if (!gsl_engine_threaded)
+    return _engine_master_check (loop);
+  else
+    return FALSE;
+}
+
+void
+gsl_engine_dispatch (void)
+{
+  g_return_if_fail (gsl_engine_initialized == TRUE);
+
+  if (!gsl_engine_threaded)
+    _engine_master_dispatch ();
+}
+
+/**
+ * gsl_engine_wait_on_trans
+ *
+ * Wait until all pending transactions have been processed
+ * by the GSL Engine.
+ * This function may cause garbage collection (see
+ * gsl_engine_garbage_collect()).
+ */
+void
+gsl_engine_wait_on_trans (void)
+{
+  g_return_if_fail (gsl_engine_initialized == TRUE);
+
+  /* non-threaded */
+  if (!gsl_engine_threaded)
+    _engine_master_dispatch_jobs ();
+
+  /* threaded */
+  _engine_wait_on_trans ();
+
+  /* call all free() functions */
+  gsl_engine_garbage_collect ();
+}
+
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gslengine.h b/flow/gsl/gslengine.h
new file mode 100644
index 0000000..34f8f80
--- /dev/null
+++ b/flow/gsl/gslengine.h
@@ -0,0 +1,206 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_ENGINE_H__
+#define __GSL_ENGINE_H__
+
+#include	<gsl/gsldefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+/* --- constants --- */
+#define	GSL_STREAM_MAX_VALUES		        (8192 /* power of 2, <= 16384 */)	/* FIXME */
+#define	GSL_MODULE_N_OSTREAMS(module)	        ((module)->klass->n_ostreams)
+#define	GSL_MODULE_N_ISTREAMS(module)	        ((module)->klass->n_istreams)
+#define	GSL_MODULE_N_JSTREAMS(module)	        ((module)->klass->n_jstreams)
+#define	GSL_MODULE_ISTREAM(module, stream)      ((module)->istreams[(stream)])
+#define	GSL_MODULE_JSTREAM(module, stream)      ((module)->jstreams[(stream)])
+#define	GSL_MODULE_OSTREAM(module, stream)      ((module)->ostreams[(stream)])
+#define	GSL_MODULE_IBUFFER(module, stream)      (GSL_MODULE_ISTREAM ((module), (stream)).values)
+#define	GSL_MODULE_JBUFFER(module, stream, con) (GSL_MODULE_JSTREAM ((module), (stream)).values[con])
+#define	GSL_MODULE_OBUFFER(module, stream)      (GSL_MODULE_OSTREAM ((module), (stream)).values)
+
+
+/* --- typedefs --- */
+typedef gboolean (*GslPollFunc)		(gpointer	data,
+					 guint		n_values,
+					 glong	       *timeout_p,
+					 guint          n_fds,
+					 const GPollFD *fds,
+					 gboolean	revents_filled);
+typedef void     (*GslProcessFunc)	(GslModule	 *module,
+					 guint		  n_values);
+typedef guint    (*GslProcessDeferFunc)	(GslModule	 *module,
+					 guint		  n_ivalues,
+					 guint		  n_ovalues);
+typedef void     (*GslReconnectFunc)	(GslModule	 *module);
+/* gsldefs.h:
+ * typedef void  (*GslAccessFunc)	(GslModule	*module,
+ *					 gpointer	 data);
+ * typedef void  (*GslFreeFunc)		(gpointer	 data);
+ * typedef void  (*GslModuleFreeFunc)	(gpointer	 data,
+ *                                       const GslClass *klass);
+ */
+typedef enum	/*< skip >*/
+{
+  GSL_COST_NORMAL	= 0,
+  GSL_COST_CHEAP	= 1 << 0,
+  GSL_COST_EXPENSIVE	= 1 << 1
+} GslModuleFlags;
+/* class, filled out by user */
+struct _GslClass
+{
+  guint		      n_istreams;
+  guint		      n_jstreams;
+  guint		      n_ostreams;
+  GslProcessFunc      process;		/* EngineThread */
+  GslProcessDeferFunc process_defer;	/* EngineThread */
+  GslReconnectFunc    reconnect;	/* EngineThread */
+  GslModuleFreeFunc   free;		/* UserThread */
+  GslModuleFlags      mflags;
+};
+/* module, constructed by engine */
+struct _GslModule
+{
+  const GslClass *klass;
+  gpointer	  user_data;
+  GslIStream	 *istreams;	/* input streams */
+  GslJStream	 *jstreams;	/* joint (multiconnect) input streams */
+  GslOStream	 *ostreams;	/* output streams */
+};
+/* streams, constructed by engine */
+struct _GslJStream
+{
+  const gfloat **values;
+  guint          n_connections;
+  guint		 reserved : 16;
+};
+struct _GslIStream
+{
+  const gfloat *values;
+  guint		reserved : 16;
+  guint		connected : 1;
+};
+struct _GslOStream
+{
+  gfloat     *values;
+  guint	      sub_sample_pattern : 16;
+  guint	      connected : 1;
+};
+
+
+/* --- interface (UserThread functions) --- */
+GslModule*	gsl_module_new		(const GslClass	 *klass,
+					 gpointer	  user_data);
+guint64		gsl_module_tick_stamp	(GslModule	 *module);
+GslJob*		gsl_job_connect		(GslModule	 *src_module,
+					 guint		  src_ostream,
+					 GslModule	 *dest_module,
+					 guint		  dest_istream);
+GslJob*		gsl_job_jconnect	(GslModule	 *src_module,
+					 guint		  src_ostream,
+					 GslModule	 *dest_module,
+					 guint		  dest_jstream);
+GslJob*		gsl_job_disconnect	(GslModule	 *dest_module,
+					 guint		  dest_istream);
+GslJob*		gsl_job_jdisconnect	(GslModule	 *dest_module,
+					 guint		  dest_jstream,
+					 GslModule	 *src_module,
+					 guint		  src_ostream);
+GslJob*		gsl_job_integrate	(GslModule	 *module);
+GslJob*		gsl_job_discard		(GslModule	 *module);
+GslJob*		gsl_job_access		(GslModule	 *module,
+					 GslAccessFunc	  access_func,	/* EngineThread */
+					 gpointer	  data,
+					 GslFreeFunc	  free_func);	/* UserThread */
+GslJob*		gsl_job_set_consumer	(GslModule	 *module,
+					 gboolean	  is_toplevel_consumer);
+GslJob*		gsl_job_debug		(const gchar	 *debug);
+GslJob*		gsl_job_add_poll	(GslPollFunc	  poll_func,
+					 gpointer	  data,
+					 GslFreeFunc	  free_func,
+					 guint		  n_fds,
+					 const GPollFD   *fds);
+GslJob*		gsl_job_remove_poll	(GslPollFunc	  poll_func,
+					 gpointer	  data);
+GslTrans*	gsl_trans_open		(void);
+void		gsl_trans_add		(GslTrans	 *trans,
+					 GslJob		 *job);
+void		gsl_trans_commit	(GslTrans	 *trans);
+void		gsl_trans_dismiss	(GslTrans	 *trans);
+void		gsl_transact		(GslJob		 *job,
+					 ...);
+GslJob*		gsl_flow_job_access	(GslModule	 *module,
+					 guint64	  tick_stamp,
+					 GslAccessFunc	  access_func,	/* EngineThread */
+					 gpointer	  data,
+					 GslFreeFunc	  free_func);	/* UserThread */
+GslJob*		gsl_flow_job_suspend	(GslModule	 *module,
+					 guint64	  tick_stamp);
+GslJob*		gsl_flow_job_resume	(GslModule	 *module,
+					 guint64	  tick_stamp);
+
+
+/* --- module utilities --- */
+gfloat*		gsl_engine_const_values	(gfloat		 value);
+
+
+/* --- initialization & main loop --- */
+void	        gsl_engine_init		(gboolean	 threaded,
+					 guint		 block_size,
+					 guint		 sample_freq,
+					 guint		 sub_sample_mask);
+typedef struct
+{
+  glong		timeout;
+  gboolean	fds_changed;
+  guint		n_fds;
+  GPollFD      *fds;
+  gboolean	revents_filled;
+} GslEngineLoop;
+gboolean        gsl_engine_prepare	(GslEngineLoop		*loop);
+gboolean        gsl_engine_check	(const GslEngineLoop	*loop);
+void	        gsl_engine_dispatch	(void);
+
+
+/* --- miscellaneous --- */
+void	      gsl_engine_garbage_collect	(void);
+void	      gsl_engine_wait_on_trans		(void);
+#define	      gsl_engine_block_size()		((const guint)	gsl_externvar_bsize + 0)
+#define	      gsl_engine_sample_freq()		((const guint)	gsl_externvar_sample_freq + 0)
+#define	      gsl_engine_sub_sample_mask()	((const guint)	gsl_externvar_sub_sample_mask + 0)
+#define	      gsl_engine_sub_sample_steps()	((const guint)	gsl_externvar_sub_sample_steps + 0)
+#define	      gsl_engine_sub_sample_test(ptr)	(((guint) (ptr)) & gsl_engine_sub_sample_mask ())
+#define	      GSL_SUB_SAMPLE_MATCH(ptr,sspatrn)	(gsl_engine_sub_sample_test (ptr) == (sspatrn))
+
+
+/*< private >*/
+extern guint	gsl_externvar_bsize;
+extern guint	gsl_externvar_sample_freq;
+extern guint	gsl_externvar_sub_sample_mask;
+extern guint	gsl_externvar_sub_sample_steps;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_ENGINE_H__ */
diff --git a/flow/gsl/gslfft.c b/flow/gsl/gslfft.c
new file mode 100644
index 0000000..48f56ef
--- /dev/null
+++ b/flow/gsl/gslfft.c
@@ -0,0 +1,9052 @@
+#include "gslfft.h"
+#include <math.h>
+
+#define BUTTERFLY_XY(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim) { \
+  register double T1re, T1im, T2re, T2im; \
+  T1re = X2re * Wre;  \
+  T1im = X2im * Wre;  \
+  T2re = X2im * Wim;  \
+  T2im = X2re * Wim;  \
+  T1re -= T2re;       \
+  T1im += T2im;       \
+  T2re = X1re - T1re; \
+  T2im = X1im - T1im; \
+  Y1re = X1re + T1re; \
+  Y1im = X1im + T1im; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_Yx(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim) { \
+  register double T1re, T1im, T2re, T2im; \
+  T1re = X2re * Wim;  \
+  T1im = X2im * Wim;  \
+  T2re = X2im * Wre;  \
+  T2im = X2re * Wre;  \
+  T1re += T2re;       \
+  T1im -= T2im;       \
+  T2re = X1re + T1re; \
+  T2im = X1im + T1im; \
+  Y1re = X1re - T1re; \
+  Y1im = X1im - T1im; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_yX(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim) { \
+  register double T1re, T1im, T2re, T2im; \
+  T1re = X2re * Wim;  \
+  T1im = X2im * Wim;  \
+  T2re = X2im * Wre;  \
+  T2im = X2re * Wre;  \
+  T1re += T2re;       \
+  T1im -= T2im;       \
+  T2re = X1re - T1re; \
+  T2im = X1im - T1im; \
+  Y1re = X1re + T1re; \
+  Y1im = X1im + T1im; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_10(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \
+  register double T2re, T2im; \
+  T2re = X1re - X2re; \
+  T2im = X1im - X2im; \
+  Y1re = X1re + X2re; \
+  Y1im = X1im + X2im; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_01(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \
+  register double T2re, T2im; \
+  T2re = X1re + X2im; \
+  T2im = X1im - X2re; \
+  Y1re = X1re - X2im; \
+  Y1im = X1im + X2re; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_0m(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \
+  register double T2re, T2im; \
+  T2re = X1re - X2im; \
+  T2im = X1im + X2re; \
+  Y1re = X1re + X2im; \
+  Y1im = X1im - X2re; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_XX(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,_2) { \
+  register double T1re, T1im, T2re, T2im; \
+  T1re = X2re * Wre;  \
+  T1im = X2im * Wre;  \
+  T2re = T1im; \
+  T2im = T1re; \
+  T1re -= T2re;       \
+  T1im += T2im;       \
+  T2re = X1re - T1re; \
+  T2im = X1im - T1im; \
+  Y1re = X1re + T1re; \
+  Y1im = X1im + T1im; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_yY(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,_2) { \
+  register double T1re, T1im, T2re, T2im; \
+  T1re = X2re * Wre;  \
+  T1im = X2im * Wre;  \
+  T2re = T1im;  \
+  T2im = T1re;  \
+  T1re += T2re;       \
+  T1im -= T2im;       \
+  T2re = X1re - T1re; \
+  T2im = X1im - T1im; \
+  Y1re = X1re + T1re; \
+  Y1im = X1im + T1im; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_10scale(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,S) { \
+  register double T2re, T2im; \
+  T2re = X1re - X2re; \
+  T2im = X1im - X2im; \
+  Y1re = X1re + X2re; \
+  Y1im = X1im + X2im; \
+  Y2re = T2re * S;    \
+  Y2im = T2im * S;    \
+  Y1re *= S;          \
+  Y1im *= S;          \
+}
+
+#define WMULTIPLY(Wre,Wim,Dre,Dim) { \
+  register double T1re, T1im, T2re, T2im; \
+  T1re = Wre * Dre;  \
+  T1im = Wim * Dre;  \
+  T2re = Wim * Dim;  \
+  T2im = Wre * Dim;  \
+  T1re -= T2re;      \
+  T1im += T2im;      \
+  Wre += T1re;       \
+  Wim += T1im;       \
+}
+static inline void
+bitreverse_fft2analysis (const unsigned int n,
+                         const double        *X,
+                         double              *Y)
+{
+  const unsigned int n2 = n >> 1, n1 = n + n2, max = n >> 2;
+  unsigned int i, r;
+  
+  BUTTERFLY_10 (X[0], X[1],
+		X[n], X[n + 1],
+		Y[0], Y[1],
+		Y[2], Y[3],
+		__1, __0);
+  BUTTERFLY_10 (X[n2], X[n2 + 1],
+		X[n1], X[n1 + 1],
+		Y[4], Y[5],
+		Y[6], Y[7],
+		__1, __0);
+  for (i = 1, r = 0; i < max; i++)
+    {
+      unsigned int k, j = n >> 1;
+
+      while (r >= j)
+	{
+	  r -= j;
+	  j >>= 1;
+	}
+      r |= j;
+
+      k = r >> 1;
+      j = i << 3;
+      BUTTERFLY_10 (X[k], X[k + 1],
+		    X[k + n], X[k + n + 1],
+		    Y[j], Y[j + 1],
+		    Y[j + 2], Y[j + 3],
+		    __1, __0);
+      k += n2;
+      j += 4;
+      BUTTERFLY_10 (X[k], X[k + 1],
+		    X[k + n], X[k + n + 1],
+		    Y[j], Y[j + 1],
+		    Y[j + 2], Y[j + 3],
+		    __1, __0);
+    }
+}
+static inline void
+bitreverse_fft2synthesis (const unsigned int n,
+                          const double        *X,
+                          double              *Y)
+{
+  const unsigned int n2 = n >> 1, n1 = n + n2, max = n >> 2;
+  unsigned int i, r;
+  double scale = n;
+
+  scale = 1.0 / scale;
+  BUTTERFLY_10scale (X[0], X[1],
+		     X[n], X[n + 1],
+		     Y[0], Y[1],
+		     Y[2], Y[3],
+		     scale);
+  BUTTERFLY_10scale (X[n2], X[n2 + 1],
+		     X[n1], X[n1 + 1],
+		     Y[4], Y[5],
+		     Y[6], Y[7],
+		     scale);
+  for (i = 1, r = 0; i < max; i++)
+    {
+      unsigned int k, j = n >> 1;
+
+      while (r >= j)
+	{
+	  r -= j;
+	  j >>= 1;
+	}
+      r |= j;
+
+      k = r >> 1;
+      j = i << 3;
+      BUTTERFLY_10scale (X[k], X[k + 1],
+			 X[k + n], X[k + n + 1],
+			 Y[j], Y[j + 1],
+			 Y[j + 2], Y[j + 3],
+			 scale);
+      k += n2;
+      j += 4;
+      BUTTERFLY_10scale (X[k], X[k + 1],
+			 X[k + n], X[k + n + 1],
+			 Y[j], Y[j + 1],
+			 Y[j + 2], Y[j + 3],
+			 scale);
+    }
+}
+/**
+ ** Generated data (by gsl-genfft 2 F)
+ **/
+static void
+gsl_power2_fft2analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 1 times fft2 */
+  BUTTERFLY_10 (X[0], X[0 + 1],
+                  X[2], X[2 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  __1, __0);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 4 S F)
+ **/
+static void
+gsl_power2_fft4analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 2 times fft2 */
+
+  /* perform 1 times fft4 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_01 (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 4 F X)
+ **/
+static void
+gsl_power2_fft4analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 2 times fft2 */
+  BUTTERFLY_10 (X[0], X[0 + 1],
+                  X[4], X[4 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[2], X[2 + 1],
+                  X[6], X[6 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  __1, __0);
+
+  /* perform 1 times fft4 */
+  gsl_power2_fft4analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 8 S F F)
+ **/
+static void
+gsl_power2_fft8analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 4 times fft2 */
+
+  /* perform 2 times fft4 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[8],               /* W0 */
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_01 (Y[2],               /* W2 */
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[10],               /* W2 */
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+
+  /* perform 1 times fft8 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XX (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_01 (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_yY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 8 F S X)
+ **/
+static void
+gsl_power2_fft8analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 4 times fft2 */
+  BUTTERFLY_10 (X[0], X[0 + 1],
+                  X[8], X[8 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[4], X[4 + 1],
+                  X[12], X[12 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[2], X[2 + 1],
+                  X[10], X[10 + 1],
+                  Y[8], Y[8 + 1],
+                  Y[10], Y[10 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[6], X[6 + 1],
+                  X[14], X[14 + 1],
+                  Y[12], Y[12 + 1],
+                  Y[14], Y[14 + 1],
+                  __1, __0);
+
+  /* skipping 2 times fft4 */
+
+  /* perform 1 times fft8 */
+  gsl_power2_fft8analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 16 S F F F)
+ **/
+static void
+gsl_power2_fft16analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 8 times fft2 */
+
+  /* perform 4 times fft4 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[8],               /* W0 */
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[16],               /* W0 */
+                Y[16 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[20],
+                Y[20 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[24],               /* W0 */
+                Y[24 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_01 (Y[2],               /* W4 */
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[10],               /* W4 */
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[18],               /* W4 */
+                Y[18 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[22],
+                Y[22 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[26],               /* W4 */
+                Y[26 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+
+  /* perform 2 times fft8 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[16],               /* W0 */
+                Y[16 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[24],
+                Y[24 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XX (Y[2],               /* W2 */
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XX (Y[18],               /* W2 */
+                Y[18 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[26],
+                Y[26 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_01 (Y[4],               /* W4 */
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[20],               /* W4 */
+                Y[20 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_yY (Y[6],               /* W6 */
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_yY (Y[22],               /* W6 */
+                Y[22 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+
+  /* perform 1 times fft16 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[16],
+                Y[16 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[18],
+                Y[18 + 1],
+                (double) +0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XX (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[20],
+                Y[20 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[22],
+                Y[22 + 1],
+                (double) +0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_01 (Y[8],               /* W4 */
+                Y[8 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[24],
+                Y[24 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_XY (Y[10],               /* W5 */
+                Y[10 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[26],
+                Y[26 + 1],
+                (double) -0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_yY (Y[12],               /* W6 */
+                Y[12 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_XY (Y[14],               /* W7 */
+                Y[14 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) -0.923879532511287, (double) +0.382683432365090);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 16 F S S X)
+ **/
+static void
+gsl_power2_fft16analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 8 times fft2 */
+  BUTTERFLY_10 (X[0], X[0 + 1],
+                  X[16], X[16 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[8], X[8 + 1],
+                  X[24], X[24 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[4], X[4 + 1],
+                  X[20], X[20 + 1],
+                  Y[8], Y[8 + 1],
+                  Y[10], Y[10 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[12], X[12 + 1],
+                  X[28], X[28 + 1],
+                  Y[12], Y[12 + 1],
+                  Y[14], Y[14 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[2], X[2 + 1],
+                  X[18], X[18 + 1],
+                  Y[16], Y[16 + 1],
+                  Y[18], Y[18 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[10], X[10 + 1],
+                  X[26], X[26 + 1],
+                  Y[20], Y[20 + 1],
+                  Y[22], Y[22 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[6], X[6 + 1],
+                  X[22], X[22 + 1],
+                  Y[24], Y[24 + 1],
+                  Y[26], Y[26 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[14], X[14 + 1],
+                  X[30], X[30 + 1],
+                  Y[28], Y[28 + 1],
+                  Y[30], Y[30 + 1],
+                  __1, __0);
+
+  /* skipping 4 times fft4 */
+
+  /* skipping 2 times fft8 */
+
+  /* perform 1 times fft16 */
+  gsl_power2_fft16analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 32 S F F F F)
+ **/
+static void
+gsl_power2_fft32analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 16 times fft2 */
+
+  /* perform 8 times fft4 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[8],               /* W0 */
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[16],               /* W0 */
+                Y[16 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[20],
+                Y[20 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[24],               /* W0 */
+                Y[24 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[32],               /* W0 */
+                Y[32 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[36],
+                Y[36 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[40],               /* W0 */
+                Y[40 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[44],
+                Y[44 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[48],               /* W0 */
+                Y[48 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[52],
+                Y[52 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[56],               /* W0 */
+                Y[56 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[60],
+                Y[60 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_01 (Y[2],               /* W8 */
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[10],               /* W8 */
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[18],               /* W8 */
+                Y[18 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[22],
+                Y[22 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[26],               /* W8 */
+                Y[26 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[34],               /* W8 */
+                Y[34 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[38],
+                Y[38 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[42],               /* W8 */
+                Y[42 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[46],
+                Y[46 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[50],               /* W8 */
+                Y[50 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[54],
+                Y[54 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[58],               /* W8 */
+                Y[58 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[62],
+                Y[62 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+
+  /* perform 4 times fft8 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[16],               /* W0 */
+                Y[16 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[24],
+                Y[24 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[32],               /* W0 */
+                Y[32 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[40],
+                Y[40 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[48],               /* W0 */
+                Y[48 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[56],
+                Y[56 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XX (Y[2],               /* W4 */
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XX (Y[18],               /* W4 */
+                Y[18 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[26],
+                Y[26 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XX (Y[34],               /* W4 */
+                Y[34 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[42],
+                Y[42 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XX (Y[50],               /* W4 */
+                Y[50 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[58],
+                Y[58 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_01 (Y[4],               /* W8 */
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[20],               /* W8 */
+                Y[20 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[36],               /* W8 */
+                Y[36 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[44],
+                Y[44 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[52],               /* W8 */
+                Y[52 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[60],
+                Y[60 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_yY (Y[6],               /* W12 */
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_yY (Y[22],               /* W12 */
+                Y[22 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_yY (Y[38],               /* W12 */
+                Y[38 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[46],
+                Y[46 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_yY (Y[54],               /* W12 */
+                Y[54 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[62],
+                Y[62 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+
+  /* perform 2 times fft16 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[16],
+                Y[16 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[32],               /* W0 */
+                Y[32 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[48],
+                Y[48 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W2 */
+                Y[2 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[18],
+                Y[18 + 1],
+                (double) +0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XY (Y[34],               /* W2 */
+                Y[34 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[50],
+                Y[50 + 1],
+                (double) +0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XX (Y[4],               /* W4 */
+                Y[4 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[20],
+                Y[20 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XX (Y[36],               /* W4 */
+                Y[36 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[52],
+                Y[52 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XY (Y[6],               /* W6 */
+                Y[6 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[22],
+                Y[22 + 1],
+                (double) +0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_XY (Y[38],               /* W6 */
+                Y[38 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[54],
+                Y[54 + 1],
+                (double) +0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_01 (Y[8],               /* W8 */
+                Y[8 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[24],
+                Y[24 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_01 (Y[40],               /* W8 */
+                Y[40 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[56],
+                Y[56 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_XY (Y[10],               /* W10 */
+                Y[10 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[26],
+                Y[26 + 1],
+                (double) -0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_XY (Y[42],               /* W10 */
+                Y[42 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[58],
+                Y[58 + 1],
+                (double) -0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_yY (Y[12],               /* W12 */
+                Y[12 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_yY (Y[44],               /* W12 */
+                Y[44 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[60],
+                Y[60 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_XY (Y[14],               /* W14 */
+                Y[14 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) -0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XY (Y[46],               /* W14 */
+                Y[46 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[62],
+                Y[62 + 1],
+                (double) -0.923879532511287, (double) +0.382683432365090);
+
+  /* perform 1 times fft32 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[32],
+                Y[32 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[34],
+                Y[34 + 1],
+                (double) +0.980785280403230, (double) +0.195090322016128);
+  BUTTERFLY_XY (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[36],
+                Y[36 + 1],
+                (double) +0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[38],
+                Y[38 + 1],
+                (double) +0.831469612302545, (double) +0.555570233019602);
+  BUTTERFLY_XX (Y[8],               /* W4 */
+                Y[8 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[40],
+                Y[40 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XY (Y[10],               /* W5 */
+                Y[10 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[42],
+                Y[42 + 1],
+                (double) +0.555570233019602, (double) +0.831469612302545);
+  BUTTERFLY_XY (Y[12],               /* W6 */
+                Y[12 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[44],
+                Y[44 + 1],
+                (double) +0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_XY (Y[14],               /* W7 */
+                Y[14 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[46],
+                Y[46 + 1],
+                (double) +0.195090322016128, (double) +0.980785280403230);
+  BUTTERFLY_01 (Y[16],               /* W8 */
+                Y[16 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[48],
+                Y[48 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_XY (Y[18],               /* W9 */
+                Y[18 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[50],
+                Y[50 + 1],
+                (double) -0.195090322016128, (double) +0.980785280403230);
+  BUTTERFLY_XY (Y[20],               /* W10 */
+                Y[20 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[52],
+                Y[52 + 1],
+                (double) -0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_XY (Y[22],               /* W11 */
+                Y[22 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[54],
+                Y[54 + 1],
+                (double) -0.555570233019602, (double) +0.831469612302545);
+  BUTTERFLY_yY (Y[24],               /* W12 */
+                Y[24 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[56],
+                Y[56 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_XY (Y[26],               /* W13 */
+                Y[26 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[58],
+                Y[58 + 1],
+                (double) -0.831469612302545, (double) +0.555570233019602);
+  BUTTERFLY_XY (Y[28],               /* W14 */
+                Y[28 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[60],
+                Y[60 + 1],
+                (double) -0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XY (Y[30],               /* W15 */
+                Y[30 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[62],
+                Y[62 + 1],
+                (double) -0.980785280403230, (double) +0.195090322016129);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 32 F S S S X)
+ **/
+static void
+gsl_power2_fft32analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 16 times fft2 */
+  BUTTERFLY_10 (X[0], X[0 + 1],
+                  X[32], X[32 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[16], X[16 + 1],
+                  X[48], X[48 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[8], X[8 + 1],
+                  X[40], X[40 + 1],
+                  Y[8], Y[8 + 1],
+                  Y[10], Y[10 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[24], X[24 + 1],
+                  X[56], X[56 + 1],
+                  Y[12], Y[12 + 1],
+                  Y[14], Y[14 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[4], X[4 + 1],
+                  X[36], X[36 + 1],
+                  Y[16], Y[16 + 1],
+                  Y[18], Y[18 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[20], X[20 + 1],
+                  X[52], X[52 + 1],
+                  Y[20], Y[20 + 1],
+                  Y[22], Y[22 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[12], X[12 + 1],
+                  X[44], X[44 + 1],
+                  Y[24], Y[24 + 1],
+                  Y[26], Y[26 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[28], X[28 + 1],
+                  X[60], X[60 + 1],
+                  Y[28], Y[28 + 1],
+                  Y[30], Y[30 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[2], X[2 + 1],
+                  X[34], X[34 + 1],
+                  Y[32], Y[32 + 1],
+                  Y[34], Y[34 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[18], X[18 + 1],
+                  X[50], X[50 + 1],
+                  Y[36], Y[36 + 1],
+                  Y[38], Y[38 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[10], X[10 + 1],
+                  X[42], X[42 + 1],
+                  Y[40], Y[40 + 1],
+                  Y[42], Y[42 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[26], X[26 + 1],
+                  X[58], X[58 + 1],
+                  Y[44], Y[44 + 1],
+                  Y[46], Y[46 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[6], X[6 + 1],
+                  X[38], X[38 + 1],
+                  Y[48], Y[48 + 1],
+                  Y[50], Y[50 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[22], X[22 + 1],
+                  X[54], X[54 + 1],
+                  Y[52], Y[52 + 1],
+                  Y[54], Y[54 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[14], X[14 + 1],
+                  X[46], X[46 + 1],
+                  Y[56], Y[56 + 1],
+                  Y[58], Y[58 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[30], X[30 + 1],
+                  X[62], X[62 + 1],
+                  Y[60], Y[60 + 1],
+                  Y[62], Y[62 + 1],
+                  __1, __0);
+
+  /* skipping 8 times fft4 */
+
+  /* skipping 4 times fft8 */
+
+  /* skipping 2 times fft16 */
+
+  /* perform 1 times fft32 */
+  gsl_power2_fft32analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 64 S R R R R F)
+ **/
+static void
+gsl_power2_fft64analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 32 times fft2 */
+
+  /* perform 16 times fft4 */
+  for (block = 0; block < 128; block += 8) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_01 (Y[block + 2],               /* W16 */
+                  Y[block + 2 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+  }
+
+  /* perform 8 times fft8 */
+  for (block = 0; block < 128; block += 16) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XX (Y[block + 2],               /* W8 */
+                  Y[block + 2 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  (double) +0.707106781186548, (double) +0.707106781186547);
+    BUTTERFLY_01 (Y[block + 4],               /* W16 */
+                  Y[block + 4 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+    BUTTERFLY_yY (Y[block + 6],               /* W24 */
+                  Y[block + 6 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  (double) -0.707106781186547, (double) +0.707106781186548);
+  }
+
+  /* perform 4 times fft16 */
+  for (block = 0; block < 128; block += 32) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W4 */
+                  Y[block + 2 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  (double) +0.923879532511287, (double) +0.382683432365090);
+    BUTTERFLY_XX (Y[block + 4],               /* W8 */
+                  Y[block + 4 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  (double) +0.707106781186548, (double) +0.707106781186547);
+    BUTTERFLY_XY (Y[block + 6],               /* W12 */
+                  Y[block + 6 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  (double) +0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_01 (Y[block + 8],               /* W16 */
+                  Y[block + 8 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+    BUTTERFLY_XY (Y[block + 10],               /* W20 */
+                  Y[block + 10 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  (double) -0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_yY (Y[block + 12],               /* W24 */
+                  Y[block + 12 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  (double) -0.707106781186547, (double) +0.707106781186548);
+    BUTTERFLY_XY (Y[block + 14],               /* W28 */
+                  Y[block + 14 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  (double) -0.923879532511287, (double) +0.382683432365090);
+  }
+
+  /* perform 2 times fft32 */
+  for (block = 0; block < 128; block += 64) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W2 */
+                  Y[block + 2 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  (double) +0.980785280403230, (double) +0.195090322016128);
+    BUTTERFLY_XY (Y[block + 4],               /* W4 */
+                  Y[block + 4 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  (double) +0.923879532511287, (double) +0.382683432365090);
+    BUTTERFLY_XY (Y[block + 6],               /* W6 */
+                  Y[block + 6 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  (double) +0.831469612302545, (double) +0.555570233019602);
+    BUTTERFLY_XX (Y[block + 8],               /* W8 */
+                  Y[block + 8 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  (double) +0.707106781186548, (double) +0.707106781186547);
+    BUTTERFLY_XY (Y[block + 10],               /* W10 */
+                  Y[block + 10 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  (double) +0.555570233019602, (double) +0.831469612302545);
+    BUTTERFLY_XY (Y[block + 12],               /* W12 */
+                  Y[block + 12 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  (double) +0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_XY (Y[block + 14],               /* W14 */
+                  Y[block + 14 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  (double) +0.195090322016128, (double) +0.980785280403230);
+    BUTTERFLY_01 (Y[block + 16],               /* W16 */
+                  Y[block + 16 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+    BUTTERFLY_XY (Y[block + 18],               /* W18 */
+                  Y[block + 18 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  (double) -0.195090322016128, (double) +0.980785280403230);
+    BUTTERFLY_XY (Y[block + 20],               /* W20 */
+                  Y[block + 20 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  (double) -0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_XY (Y[block + 22],               /* W22 */
+                  Y[block + 22 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  (double) -0.555570233019602, (double) +0.831469612302545);
+    BUTTERFLY_yY (Y[block + 24],               /* W24 */
+                  Y[block + 24 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  (double) -0.707106781186547, (double) +0.707106781186548);
+    BUTTERFLY_XY (Y[block + 26],               /* W26 */
+                  Y[block + 26 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  (double) -0.831469612302545, (double) +0.555570233019602);
+    BUTTERFLY_XY (Y[block + 28],               /* W28 */
+                  Y[block + 28 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  (double) -0.923879532511287, (double) +0.382683432365090);
+    BUTTERFLY_XY (Y[block + 30],               /* W30 */
+                  Y[block + 30 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  (double) -0.980785280403230, (double) +0.195090322016129);
+  }
+
+  /* perform 1 times fft64 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[64],
+                Y[64 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[64],
+                Y[64 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[66],
+                Y[66 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[66],
+                Y[66 + 1],
+                (double) +0.995184726672197, (double) +0.098017140329561);
+  BUTTERFLY_XY (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[68],
+                Y[68 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[68],
+                Y[68 + 1],
+                (double) +0.980785280403230, (double) +0.195090322016128);
+  BUTTERFLY_XY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[70],
+                Y[70 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[70],
+                Y[70 + 1],
+                (double) +0.956940335732209, (double) +0.290284677254462);
+  BUTTERFLY_XY (Y[8],               /* W4 */
+                Y[8 + 1],
+                Y[72],
+                Y[72 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[72],
+                Y[72 + 1],
+                (double) +0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XY (Y[10],               /* W5 */
+                Y[10 + 1],
+                Y[74],
+                Y[74 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[74],
+                Y[74 + 1],
+                (double) +0.881921264348355, (double) +0.471396736825998);
+  BUTTERFLY_XY (Y[12],               /* W6 */
+                Y[12 + 1],
+                Y[76],
+                Y[76 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[76],
+                Y[76 + 1],
+                (double) +0.831469612302545, (double) +0.555570233019602);
+  BUTTERFLY_XY (Y[14],               /* W7 */
+                Y[14 + 1],
+                Y[78],
+                Y[78 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[78],
+                Y[78 + 1],
+                (double) +0.773010453362737, (double) +0.634393284163645);
+  BUTTERFLY_XX (Y[16],               /* W8 */
+                Y[16 + 1],
+                Y[80],
+                Y[80 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[80],
+                Y[80 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XY (Y[18],               /* W9 */
+                Y[18 + 1],
+                Y[82],
+                Y[82 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[82],
+                Y[82 + 1],
+                (double) +0.634393284163645, (double) +0.773010453362737);
+  BUTTERFLY_XY (Y[20],               /* W10 */
+                Y[20 + 1],
+                Y[84],
+                Y[84 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[84],
+                Y[84 + 1],
+                (double) +0.555570233019602, (double) +0.831469612302545);
+  BUTTERFLY_XY (Y[22],               /* W11 */
+                Y[22 + 1],
+                Y[86],
+                Y[86 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[86],
+                Y[86 + 1],
+                (double) +0.471396736825998, (double) +0.881921264348355);
+  BUTTERFLY_XY (Y[24],               /* W12 */
+                Y[24 + 1],
+                Y[88],
+                Y[88 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[88],
+                Y[88 + 1],
+                (double) +0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_XY (Y[26],               /* W13 */
+                Y[26 + 1],
+                Y[90],
+                Y[90 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[90],
+                Y[90 + 1],
+                (double) +0.290284677254462, (double) +0.956940335732209);
+  BUTTERFLY_XY (Y[28],               /* W14 */
+                Y[28 + 1],
+                Y[92],
+                Y[92 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[92],
+                Y[92 + 1],
+                (double) +0.195090322016128, (double) +0.980785280403230);
+  BUTTERFLY_XY (Y[30],               /* W15 */
+                Y[30 + 1],
+                Y[94],
+                Y[94 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[94],
+                Y[94 + 1],
+                (double) +0.098017140329561, (double) +0.995184726672197);
+  BUTTERFLY_01 (Y[32],               /* W16 */
+                Y[32 + 1],
+                Y[96],
+                Y[96 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[96],
+                Y[96 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_XY (Y[34],               /* W17 */
+                Y[34 + 1],
+                Y[98],
+                Y[98 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[98],
+                Y[98 + 1],
+                (double) -0.098017140329561, (double) +0.995184726672197);
+  BUTTERFLY_XY (Y[36],               /* W18 */
+                Y[36 + 1],
+                Y[100],
+                Y[100 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[100],
+                Y[100 + 1],
+                (double) -0.195090322016128, (double) +0.980785280403230);
+  BUTTERFLY_XY (Y[38],               /* W19 */
+                Y[38 + 1],
+                Y[102],
+                Y[102 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[102],
+                Y[102 + 1],
+                (double) -0.290284677254462, (double) +0.956940335732209);
+  BUTTERFLY_XY (Y[40],               /* W20 */
+                Y[40 + 1],
+                Y[104],
+                Y[104 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[104],
+                Y[104 + 1],
+                (double) -0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_XY (Y[42],               /* W21 */
+                Y[42 + 1],
+                Y[106],
+                Y[106 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[106],
+                Y[106 + 1],
+                (double) -0.471396736825998, (double) +0.881921264348355);
+  BUTTERFLY_XY (Y[44],               /* W22 */
+                Y[44 + 1],
+                Y[108],
+                Y[108 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[108],
+                Y[108 + 1],
+                (double) -0.555570233019602, (double) +0.831469612302545);
+  BUTTERFLY_XY (Y[46],               /* W23 */
+                Y[46 + 1],
+                Y[110],
+                Y[110 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[110],
+                Y[110 + 1],
+                (double) -0.634393284163645, (double) +0.773010453362737);
+  BUTTERFLY_yY (Y[48],               /* W24 */
+                Y[48 + 1],
+                Y[112],
+                Y[112 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[112],
+                Y[112 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_XY (Y[50],               /* W25 */
+                Y[50 + 1],
+                Y[114],
+                Y[114 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[114],
+                Y[114 + 1],
+                (double) -0.773010453362737, (double) +0.634393284163645);
+  BUTTERFLY_XY (Y[52],               /* W26 */
+                Y[52 + 1],
+                Y[116],
+                Y[116 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[116],
+                Y[116 + 1],
+                (double) -0.831469612302545, (double) +0.555570233019602);
+  BUTTERFLY_XY (Y[54],               /* W27 */
+                Y[54 + 1],
+                Y[118],
+                Y[118 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[118],
+                Y[118 + 1],
+                (double) -0.881921264348355, (double) +0.471396736825998);
+  BUTTERFLY_XY (Y[56],               /* W28 */
+                Y[56 + 1],
+                Y[120],
+                Y[120 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[120],
+                Y[120 + 1],
+                (double) -0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XY (Y[58],               /* W29 */
+                Y[58 + 1],
+                Y[122],
+                Y[122 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[122],
+                Y[122 + 1],
+                (double) -0.956940335732209, (double) +0.290284677254462);
+  BUTTERFLY_XY (Y[60],               /* W30 */
+                Y[60 + 1],
+                Y[124],
+                Y[124 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[124],
+                Y[124 + 1],
+                (double) -0.980785280403230, (double) +0.195090322016129);
+  BUTTERFLY_XY (Y[62],               /* W31 */
+                Y[62 + 1],
+                Y[126],
+                Y[126 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[126],
+                Y[126 + 1],
+                (double) -0.995184726672197, (double) +0.098017140329561);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 64 F S S S S X)
+ **/
+static void
+gsl_power2_fft64analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 32 times fft2 */
+  BUTTERFLY_10 (X[0], X[0 + 1],
+                  X[64], X[64 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[32], X[32 + 1],
+                  X[96], X[96 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[16], X[16 + 1],
+                  X[80], X[80 + 1],
+                  Y[8], Y[8 + 1],
+                  Y[10], Y[10 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[48], X[48 + 1],
+                  X[112], X[112 + 1],
+                  Y[12], Y[12 + 1],
+                  Y[14], Y[14 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[8], X[8 + 1],
+                  X[72], X[72 + 1],
+                  Y[16], Y[16 + 1],
+                  Y[18], Y[18 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[40], X[40 + 1],
+                  X[104], X[104 + 1],
+                  Y[20], Y[20 + 1],
+                  Y[22], Y[22 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[24], X[24 + 1],
+                  X[88], X[88 + 1],
+                  Y[24], Y[24 + 1],
+                  Y[26], Y[26 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[56], X[56 + 1],
+                  X[120], X[120 + 1],
+                  Y[28], Y[28 + 1],
+                  Y[30], Y[30 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[4], X[4 + 1],
+                  X[68], X[68 + 1],
+                  Y[32], Y[32 + 1],
+                  Y[34], Y[34 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[36], X[36 + 1],
+                  X[100], X[100 + 1],
+                  Y[36], Y[36 + 1],
+                  Y[38], Y[38 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[20], X[20 + 1],
+                  X[84], X[84 + 1],
+                  Y[40], Y[40 + 1],
+                  Y[42], Y[42 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[52], X[52 + 1],
+                  X[116], X[116 + 1],
+                  Y[44], Y[44 + 1],
+                  Y[46], Y[46 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[12], X[12 + 1],
+                  X[76], X[76 + 1],
+                  Y[48], Y[48 + 1],
+                  Y[50], Y[50 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[44], X[44 + 1],
+                  X[108], X[108 + 1],
+                  Y[52], Y[52 + 1],
+                  Y[54], Y[54 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[28], X[28 + 1],
+                  X[92], X[92 + 1],
+                  Y[56], Y[56 + 1],
+                  Y[58], Y[58 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[60], X[60 + 1],
+                  X[124], X[124 + 1],
+                  Y[60], Y[60 + 1],
+                  Y[62], Y[62 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[2], X[2 + 1],
+                  X[66], X[66 + 1],
+                  Y[64], Y[64 + 1],
+                  Y[66], Y[66 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[34], X[34 + 1],
+                  X[98], X[98 + 1],
+                  Y[68], Y[68 + 1],
+                  Y[70], Y[70 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[18], X[18 + 1],
+                  X[82], X[82 + 1],
+                  Y[72], Y[72 + 1],
+                  Y[74], Y[74 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[50], X[50 + 1],
+                  X[114], X[114 + 1],
+                  Y[76], Y[76 + 1],
+                  Y[78], Y[78 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[10], X[10 + 1],
+                  X[74], X[74 + 1],
+                  Y[80], Y[80 + 1],
+                  Y[82], Y[82 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[42], X[42 + 1],
+                  X[106], X[106 + 1],
+                  Y[84], Y[84 + 1],
+                  Y[86], Y[86 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[26], X[26 + 1],
+                  X[90], X[90 + 1],
+                  Y[88], Y[88 + 1],
+                  Y[90], Y[90 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[58], X[58 + 1],
+                  X[122], X[122 + 1],
+                  Y[92], Y[92 + 1],
+                  Y[94], Y[94 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[6], X[6 + 1],
+                  X[70], X[70 + 1],
+                  Y[96], Y[96 + 1],
+                  Y[98], Y[98 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[38], X[38 + 1],
+                  X[102], X[102 + 1],
+                  Y[100], Y[100 + 1],
+                  Y[102], Y[102 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[22], X[22 + 1],
+                  X[86], X[86 + 1],
+                  Y[104], Y[104 + 1],
+                  Y[106], Y[106 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[54], X[54 + 1],
+                  X[118], X[118 + 1],
+                  Y[108], Y[108 + 1],
+                  Y[110], Y[110 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[14], X[14 + 1],
+                  X[78], X[78 + 1],
+                  Y[112], Y[112 + 1],
+                  Y[114], Y[114 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[46], X[46 + 1],
+                  X[110], X[110 + 1],
+                  Y[116], Y[116 + 1],
+                  Y[118], Y[118 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[30], X[30 + 1],
+                  X[94], X[94 + 1],
+                  Y[120], Y[120 + 1],
+                  Y[122], Y[122 + 1],
+                  __1, __0);
+  BUTTERFLY_10 (X[62], X[62 + 1],
+                  X[126], X[126 + 1],
+                  Y[124], Y[124 + 1],
+                  Y[126], Y[126 + 1],
+                  __1, __0);
+
+  /* skipping 16 times fft4 */
+
+  /* skipping 8 times fft8 */
+
+  /* skipping 4 times fft16 */
+
+  /* skipping 2 times fft32 */
+
+  /* perform 1 times fft64 */
+  gsl_power2_fft64analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 128 S R R R R R F)
+ **/
+static void
+gsl_power2_fft128analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 64 times fft2 */
+
+  /* perform 32 times fft4 */
+  for (block = 0; block < 256; block += 8) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_01 (Y[block + 2],               /* W32 */
+                  Y[block + 2 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+  }
+
+  /* perform 16 times fft8 */
+  for (block = 0; block < 256; block += 16) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XX (Y[block + 2],               /* W16 */
+                  Y[block + 2 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  (double) +0.707106781186548, (double) +0.707106781186547);
+    BUTTERFLY_01 (Y[block + 4],               /* W32 */
+                  Y[block + 4 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+    BUTTERFLY_yY (Y[block + 6],               /* W48 */
+                  Y[block + 6 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  (double) -0.707106781186547, (double) +0.707106781186548);
+  }
+
+  /* perform 8 times fft16 */
+  for (block = 0; block < 256; block += 32) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W8 */
+                  Y[block + 2 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  (double) +0.923879532511287, (double) +0.382683432365090);
+    BUTTERFLY_XX (Y[block + 4],               /* W16 */
+                  Y[block + 4 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  (double) +0.707106781186548, (double) +0.707106781186547);
+    BUTTERFLY_XY (Y[block + 6],               /* W24 */
+                  Y[block + 6 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  (double) +0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_01 (Y[block + 8],               /* W32 */
+                  Y[block + 8 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+    BUTTERFLY_XY (Y[block + 10],               /* W40 */
+                  Y[block + 10 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  (double) -0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_yY (Y[block + 12],               /* W48 */
+                  Y[block + 12 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  (double) -0.707106781186547, (double) +0.707106781186548);
+    BUTTERFLY_XY (Y[block + 14],               /* W56 */
+                  Y[block + 14 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  (double) -0.923879532511287, (double) +0.382683432365090);
+  }
+
+  /* perform 4 times fft32 */
+  for (block = 0; block < 256; block += 64) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W4 */
+                  Y[block + 2 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  (double) +0.980785280403230, (double) +0.195090322016128);
+    BUTTERFLY_XY (Y[block + 4],               /* W8 */
+                  Y[block + 4 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  (double) +0.923879532511287, (double) +0.382683432365090);
+    BUTTERFLY_XY (Y[block + 6],               /* W12 */
+                  Y[block + 6 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  (double) +0.831469612302545, (double) +0.555570233019602);
+    BUTTERFLY_XX (Y[block + 8],               /* W16 */
+                  Y[block + 8 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  (double) +0.707106781186548, (double) +0.707106781186547);
+    BUTTERFLY_XY (Y[block + 10],               /* W20 */
+                  Y[block + 10 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  (double) +0.555570233019602, (double) +0.831469612302545);
+    BUTTERFLY_XY (Y[block + 12],               /* W24 */
+                  Y[block + 12 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  (double) +0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_XY (Y[block + 14],               /* W28 */
+                  Y[block + 14 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  (double) +0.195090322016128, (double) +0.980785280403230);
+    BUTTERFLY_01 (Y[block + 16],               /* W32 */
+                  Y[block + 16 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+    BUTTERFLY_XY (Y[block + 18],               /* W36 */
+                  Y[block + 18 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  (double) -0.195090322016128, (double) +0.980785280403230);
+    BUTTERFLY_XY (Y[block + 20],               /* W40 */
+                  Y[block + 20 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  (double) -0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_XY (Y[block + 22],               /* W44 */
+                  Y[block + 22 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  (double) -0.555570233019602, (double) +0.831469612302545);
+    BUTTERFLY_yY (Y[block + 24],               /* W48 */
+                  Y[block + 24 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  (double) -0.707106781186547, (double) +0.707106781186548);
+    BUTTERFLY_XY (Y[block + 26],               /* W52 */
+                  Y[block + 26 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  (double) -0.831469612302545, (double) +0.555570233019602);
+    BUTTERFLY_XY (Y[block + 28],               /* W56 */
+                  Y[block + 28 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  (double) -0.923879532511287, (double) +0.382683432365090);
+    BUTTERFLY_XY (Y[block + 30],               /* W60 */
+                  Y[block + 30 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  (double) -0.980785280403230, (double) +0.195090322016129);
+  }
+
+  /* perform 2 times fft64 */
+  for (block = 0; block < 256; block += 128) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 64],
+                  Y[block + 64 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 64],
+                  Y[block + 64 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W2 */
+                  Y[block + 2 + 1],
+                  Y[block + 66],
+                  Y[block + 66 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 66],
+                  Y[block + 66 + 1],
+                  (double) +0.995184726672197, (double) +0.098017140329561);
+    BUTTERFLY_XY (Y[block + 4],               /* W4 */
+                  Y[block + 4 + 1],
+                  Y[block + 68],
+                  Y[block + 68 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 68],
+                  Y[block + 68 + 1],
+                  (double) +0.980785280403230, (double) +0.195090322016128);
+    BUTTERFLY_XY (Y[block + 6],               /* W6 */
+                  Y[block + 6 + 1],
+                  Y[block + 70],
+                  Y[block + 70 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 70],
+                  Y[block + 70 + 1],
+                  (double) +0.956940335732209, (double) +0.290284677254462);
+    BUTTERFLY_XY (Y[block + 8],               /* W8 */
+                  Y[block + 8 + 1],
+                  Y[block + 72],
+                  Y[block + 72 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 72],
+                  Y[block + 72 + 1],
+                  (double) +0.923879532511287, (double) +0.382683432365090);
+    BUTTERFLY_XY (Y[block + 10],               /* W10 */
+                  Y[block + 10 + 1],
+                  Y[block + 74],
+                  Y[block + 74 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 74],
+                  Y[block + 74 + 1],
+                  (double) +0.881921264348355, (double) +0.471396736825998);
+    BUTTERFLY_XY (Y[block + 12],               /* W12 */
+                  Y[block + 12 + 1],
+                  Y[block + 76],
+                  Y[block + 76 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 76],
+                  Y[block + 76 + 1],
+                  (double) +0.831469612302545, (double) +0.555570233019602);
+    BUTTERFLY_XY (Y[block + 14],               /* W14 */
+                  Y[block + 14 + 1],
+                  Y[block + 78],
+                  Y[block + 78 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 78],
+                  Y[block + 78 + 1],
+                  (double) +0.773010453362737, (double) +0.634393284163645);
+    BUTTERFLY_XX (Y[block + 16],               /* W16 */
+                  Y[block + 16 + 1],
+                  Y[block + 80],
+                  Y[block + 80 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 80],
+                  Y[block + 80 + 1],
+                  (double) +0.707106781186548, (double) +0.707106781186547);
+    BUTTERFLY_XY (Y[block + 18],               /* W18 */
+                  Y[block + 18 + 1],
+                  Y[block + 82],
+                  Y[block + 82 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 82],
+                  Y[block + 82 + 1],
+                  (double) +0.634393284163645, (double) +0.773010453362737);
+    BUTTERFLY_XY (Y[block + 20],               /* W20 */
+                  Y[block + 20 + 1],
+                  Y[block + 84],
+                  Y[block + 84 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 84],
+                  Y[block + 84 + 1],
+                  (double) +0.555570233019602, (double) +0.831469612302545);
+    BUTTERFLY_XY (Y[block + 22],               /* W22 */
+                  Y[block + 22 + 1],
+                  Y[block + 86],
+                  Y[block + 86 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 86],
+                  Y[block + 86 + 1],
+                  (double) +0.471396736825998, (double) +0.881921264348355);
+    BUTTERFLY_XY (Y[block + 24],               /* W24 */
+                  Y[block + 24 + 1],
+                  Y[block + 88],
+                  Y[block + 88 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 88],
+                  Y[block + 88 + 1],
+                  (double) +0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_XY (Y[block + 26],               /* W26 */
+                  Y[block + 26 + 1],
+                  Y[block + 90],
+                  Y[block + 90 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 90],
+                  Y[block + 90 + 1],
+                  (double) +0.290284677254462, (double) +0.956940335732209);
+    BUTTERFLY_XY (Y[block + 28],               /* W28 */
+                  Y[block + 28 + 1],
+                  Y[block + 92],
+                  Y[block + 92 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 92],
+                  Y[block + 92 + 1],
+                  (double) +0.195090322016128, (double) +0.980785280403230);
+    BUTTERFLY_XY (Y[block + 30],               /* W30 */
+                  Y[block + 30 + 1],
+                  Y[block + 94],
+                  Y[block + 94 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 94],
+                  Y[block + 94 + 1],
+                  (double) +0.098017140329561, (double) +0.995184726672197);
+    BUTTERFLY_01 (Y[block + 32],               /* W32 */
+                  Y[block + 32 + 1],
+                  Y[block + 96],
+                  Y[block + 96 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  Y[block + 96],
+                  Y[block + 96 + 1],
+                  (double) +0.000000000000000, (double) +1.000000000000000);
+    BUTTERFLY_XY (Y[block + 34],               /* W34 */
+                  Y[block + 34 + 1],
+                  Y[block + 98],
+                  Y[block + 98 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  Y[block + 98],
+                  Y[block + 98 + 1],
+                  (double) -0.098017140329561, (double) +0.995184726672197);
+    BUTTERFLY_XY (Y[block + 36],               /* W36 */
+                  Y[block + 36 + 1],
+                  Y[block + 100],
+                  Y[block + 100 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  Y[block + 100],
+                  Y[block + 100 + 1],
+                  (double) -0.195090322016128, (double) +0.980785280403230);
+    BUTTERFLY_XY (Y[block + 38],               /* W38 */
+                  Y[block + 38 + 1],
+                  Y[block + 102],
+                  Y[block + 102 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  Y[block + 102],
+                  Y[block + 102 + 1],
+                  (double) -0.290284677254462, (double) +0.956940335732209);
+    BUTTERFLY_XY (Y[block + 40],               /* W40 */
+                  Y[block + 40 + 1],
+                  Y[block + 104],
+                  Y[block + 104 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  Y[block + 104],
+                  Y[block + 104 + 1],
+                  (double) -0.382683432365090, (double) +0.923879532511287);
+    BUTTERFLY_XY (Y[block + 42],               /* W42 */
+                  Y[block + 42 + 1],
+                  Y[block + 106],
+                  Y[block + 106 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  Y[block + 106],
+                  Y[block + 106 + 1],
+                  (double) -0.471396736825998, (double) +0.881921264348355);
+    BUTTERFLY_XY (Y[block + 44],               /* W44 */
+                  Y[block + 44 + 1],
+                  Y[block + 108],
+                  Y[block + 108 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  Y[block + 108],
+                  Y[block + 108 + 1],
+                  (double) -0.555570233019602, (double) +0.831469612302545);
+    BUTTERFLY_XY (Y[block + 46],               /* W46 */
+                  Y[block + 46 + 1],
+                  Y[block + 110],
+                  Y[block + 110 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  Y[block + 110],
+                  Y[block + 110 + 1],
+                  (double) -0.634393284163645, (double) +0.773010453362737);
+    BUTTERFLY_yY (Y[block + 48],               /* W48 */
+                  Y[block + 48 + 1],
+                  Y[block + 112],
+                  Y[block + 112 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  Y[block + 112],
+                  Y[block + 112 + 1],
+                  (double) -0.707106781186547, (double) +0.707106781186548);
+    BUTTERFLY_XY (Y[block + 50],               /* W50 */
+                  Y[block + 50 + 1],
+                  Y[block + 114],
+                  Y[block + 114 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  Y[block + 114],
+                  Y[block + 114 + 1],
+                  (double) -0.773010453362737, (double) +0.634393284163645);
+    BUTTERFLY_XY (Y[block + 52],               /* W52 */
+                  Y[block + 52 + 1],
+                  Y[block + 116],
+                  Y[block + 116 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  Y[block + 116],
+                  Y[block + 116 + 1],
+                  (double) -0.831469612302545, (double) +0.555570233019602);
+    BUTTERFLY_XY (Y[block + 54],               /* W54 */
+                  Y[block + 54 + 1],
+                  Y[block + 118],
+                  Y[block + 118 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  Y[block + 118],
+                  Y[block + 118 + 1],
+                  (double) -0.881921264348355, (double) +0.471396736825998);
+    BUTTERFLY_XY (Y[block + 56],               /* W56 */
+                  Y[block + 56 + 1],
+                  Y[block + 120],
+                  Y[block + 120 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  Y[block + 120],
+                  Y[block + 120 + 1],
+                  (double) -0.923879532511287, (double) +0.382683432365090);
+    BUTTERFLY_XY (Y[block + 58],               /* W58 */
+                  Y[block + 58 + 1],
+                  Y[block + 122],
+                  Y[block + 122 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  Y[block + 122],
+                  Y[block + 122 + 1],
+                  (double) -0.956940335732209, (double) +0.290284677254462);
+    BUTTERFLY_XY (Y[block + 60],               /* W60 */
+                  Y[block + 60 + 1],
+                  Y[block + 124],
+                  Y[block + 124 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  Y[block + 124],
+                  Y[block + 124 + 1],
+                  (double) -0.980785280403230, (double) +0.195090322016129);
+    BUTTERFLY_XY (Y[block + 62],               /* W62 */
+                  Y[block + 62 + 1],
+                  Y[block + 126],
+                  Y[block + 126 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  Y[block + 126],
+                  Y[block + 126 + 1],
+                  (double) -0.995184726672197, (double) +0.098017140329561);
+  }
+
+  /* perform 1 times fft128 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[128],
+                Y[128 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[128],
+                Y[128 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[130],
+                Y[130 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[130],
+                Y[130 + 1],
+                (double) +0.998795456205172, (double) +0.049067674327418);
+  BUTTERFLY_XY (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[132],
+                Y[132 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[132],
+                Y[132 + 1],
+                (double) +0.995184726672197, (double) +0.098017140329561);
+  BUTTERFLY_XY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[134],
+                Y[134 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[134],
+                Y[134 + 1],
+                (double) +0.989176509964781, (double) +0.146730474455362);
+  BUTTERFLY_XY (Y[8],               /* W4 */
+                Y[8 + 1],
+                Y[136],
+                Y[136 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[136],
+                Y[136 + 1],
+                (double) +0.980785280403230, (double) +0.195090322016128);
+  BUTTERFLY_XY (Y[10],               /* W5 */
+                Y[10 + 1],
+                Y[138],
+                Y[138 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[138],
+                Y[138 + 1],
+                (double) +0.970031253194544, (double) +0.242980179903264);
+  BUTTERFLY_XY (Y[12],               /* W6 */
+                Y[12 + 1],
+                Y[140],
+                Y[140 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[140],
+                Y[140 + 1],
+                (double) +0.956940335732209, (double) +0.290284677254462);
+  BUTTERFLY_XY (Y[14],               /* W7 */
+                Y[14 + 1],
+                Y[142],
+                Y[142 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[142],
+                Y[142 + 1],
+                (double) +0.941544065183021, (double) +0.336889853392220);
+  BUTTERFLY_XY (Y[16],               /* W8 */
+                Y[16 + 1],
+                Y[144],
+                Y[144 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[144],
+                Y[144 + 1],
+                (double) +0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XY (Y[18],               /* W9 */
+                Y[18 + 1],
+                Y[146],
+                Y[146 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[146],
+                Y[146 + 1],
+                (double) +0.903989293123443, (double) +0.427555093430282);
+  BUTTERFLY_XY (Y[20],               /* W10 */
+                Y[20 + 1],
+                Y[148],
+                Y[148 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[148],
+                Y[148 + 1],
+                (double) +0.881921264348355, (double) +0.471396736825998);
+  BUTTERFLY_XY (Y[22],               /* W11 */
+                Y[22 + 1],
+                Y[150],
+                Y[150 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[150],
+                Y[150 + 1],
+                (double) +0.857728610000272, (double) +0.514102744193222);
+  BUTTERFLY_XY (Y[24],               /* W12 */
+                Y[24 + 1],
+                Y[152],
+                Y[152 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[152],
+                Y[152 + 1],
+                (double) +0.831469612302545, (double) +0.555570233019602);
+  BUTTERFLY_XY (Y[26],               /* W13 */
+                Y[26 + 1],
+                Y[154],
+                Y[154 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[154],
+                Y[154 + 1],
+                (double) +0.803207531480645, (double) +0.595699304492433);
+  BUTTERFLY_XY (Y[28],               /* W14 */
+                Y[28 + 1],
+                Y[156],
+                Y[156 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[156],
+                Y[156 + 1],
+                (double) +0.773010453362737, (double) +0.634393284163645);
+  BUTTERFLY_XY (Y[30],               /* W15 */
+                Y[30 + 1],
+                Y[158],
+                Y[158 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[158],
+                Y[158 + 1],
+                (double) +0.740951125354959, (double) +0.671558954847018);
+  BUTTERFLY_XX (Y[32],               /* W16 */
+                Y[32 + 1],
+                Y[160],
+                Y[160 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[160],
+                Y[160 + 1],
+                (double) +0.707106781186548, (double) +0.707106781186547);
+  BUTTERFLY_XY (Y[34],               /* W17 */
+                Y[34 + 1],
+                Y[162],
+                Y[162 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[162],
+                Y[162 + 1],
+                (double) +0.671558954847018, (double) +0.740951125354959);
+  BUTTERFLY_XY (Y[36],               /* W18 */
+                Y[36 + 1],
+                Y[164],
+                Y[164 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[164],
+                Y[164 + 1],
+                (double) +0.634393284163645, (double) +0.773010453362737);
+  BUTTERFLY_XY (Y[38],               /* W19 */
+                Y[38 + 1],
+                Y[166],
+                Y[166 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[166],
+                Y[166 + 1],
+                (double) +0.595699304492433, (double) +0.803207531480645);
+  BUTTERFLY_XY (Y[40],               /* W20 */
+                Y[40 + 1],
+                Y[168],
+                Y[168 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[168],
+                Y[168 + 1],
+                (double) +0.555570233019602, (double) +0.831469612302545);
+  BUTTERFLY_XY (Y[42],               /* W21 */
+                Y[42 + 1],
+                Y[170],
+                Y[170 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[170],
+                Y[170 + 1],
+                (double) +0.514102744193222, (double) +0.857728610000272);
+  BUTTERFLY_XY (Y[44],               /* W22 */
+                Y[44 + 1],
+                Y[172],
+                Y[172 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[172],
+                Y[172 + 1],
+                (double) +0.471396736825998, (double) +0.881921264348355);
+  BUTTERFLY_XY (Y[46],               /* W23 */
+                Y[46 + 1],
+                Y[174],
+                Y[174 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[174],
+                Y[174 + 1],
+                (double) +0.427555093430282, (double) +0.903989293123443);
+  BUTTERFLY_XY (Y[48],               /* W24 */
+                Y[48 + 1],
+                Y[176],
+                Y[176 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[176],
+                Y[176 + 1],
+                (double) +0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_XY (Y[50],               /* W25 */
+                Y[50 + 1],
+                Y[178],
+                Y[178 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[178],
+                Y[178 + 1],
+                (double) +0.336889853392220, (double) +0.941544065183021);
+  BUTTERFLY_XY (Y[52],               /* W26 */
+                Y[52 + 1],
+                Y[180],
+                Y[180 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[180],
+                Y[180 + 1],
+                (double) +0.290284677254462, (double) +0.956940335732209);
+  BUTTERFLY_XY (Y[54],               /* W27 */
+                Y[54 + 1],
+                Y[182],
+                Y[182 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[182],
+                Y[182 + 1],
+                (double) +0.242980179903264, (double) +0.970031253194544);
+  BUTTERFLY_XY (Y[56],               /* W28 */
+                Y[56 + 1],
+                Y[184],
+                Y[184 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[184],
+                Y[184 + 1],
+                (double) +0.195090322016128, (double) +0.980785280403230);
+  BUTTERFLY_XY (Y[58],               /* W29 */
+                Y[58 + 1],
+                Y[186],
+                Y[186 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[186],
+                Y[186 + 1],
+                (double) +0.146730474455362, (double) +0.989176509964781);
+  BUTTERFLY_XY (Y[60],               /* W30 */
+                Y[60 + 1],
+                Y[188],
+                Y[188 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[188],
+                Y[188 + 1],
+                (double) +0.098017140329561, (double) +0.995184726672197);
+  BUTTERFLY_XY (Y[62],               /* W31 */
+                Y[62 + 1],
+                Y[190],
+                Y[190 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[190],
+                Y[190 + 1],
+                (double) +0.049067674327418, (double) +0.998795456205172);
+  BUTTERFLY_01 (Y[64],               /* W32 */
+                Y[64 + 1],
+                Y[192],
+                Y[192 + 1],
+                Y[64],
+                Y[64 + 1],
+                Y[192],
+                Y[192 + 1],
+                (double) +0.000000000000000, (double) +1.000000000000000);
+  BUTTERFLY_XY (Y[66],               /* W33 */
+                Y[66 + 1],
+                Y[194],
+                Y[194 + 1],
+                Y[66],
+                Y[66 + 1],
+                Y[194],
+                Y[194 + 1],
+                (double) -0.049067674327418, (double) +0.998795456205172);
+  BUTTERFLY_XY (Y[68],               /* W34 */
+                Y[68 + 1],
+                Y[196],
+                Y[196 + 1],
+                Y[68],
+                Y[68 + 1],
+                Y[196],
+                Y[196 + 1],
+                (double) -0.098017140329561, (double) +0.995184726672197);
+  BUTTERFLY_XY (Y[70],               /* W35 */
+                Y[70 + 1],
+                Y[198],
+                Y[198 + 1],
+                Y[70],
+                Y[70 + 1],
+                Y[198],
+                Y[198 + 1],
+                (double) -0.146730474455362, (double) +0.989176509964781);
+  BUTTERFLY_XY (Y[72],               /* W36 */
+                Y[72 + 1],
+                Y[200],
+                Y[200 + 1],
+                Y[72],
+                Y[72 + 1],
+                Y[200],
+                Y[200 + 1],
+                (double) -0.195090322016128, (double) +0.980785280403230);
+  BUTTERFLY_XY (Y[74],               /* W37 */
+                Y[74 + 1],
+                Y[202],
+                Y[202 + 1],
+                Y[74],
+                Y[74 + 1],
+                Y[202],
+                Y[202 + 1],
+                (double) -0.242980179903264, (double) +0.970031253194544);
+  BUTTERFLY_XY (Y[76],               /* W38 */
+                Y[76 + 1],
+                Y[204],
+                Y[204 + 1],
+                Y[76],
+                Y[76 + 1],
+                Y[204],
+                Y[204 + 1],
+                (double) -0.290284677254462, (double) +0.956940335732209);
+  BUTTERFLY_XY (Y[78],               /* W39 */
+                Y[78 + 1],
+                Y[206],
+                Y[206 + 1],
+                Y[78],
+                Y[78 + 1],
+                Y[206],
+                Y[206 + 1],
+                (double) -0.336889853392220, (double) +0.941544065183021);
+  BUTTERFLY_XY (Y[80],               /* W40 */
+                Y[80 + 1],
+                Y[208],
+                Y[208 + 1],
+                Y[80],
+                Y[80 + 1],
+                Y[208],
+                Y[208 + 1],
+                (double) -0.382683432365090, (double) +0.923879532511287);
+  BUTTERFLY_XY (Y[82],               /* W41 */
+                Y[82 + 1],
+                Y[210],
+                Y[210 + 1],
+                Y[82],
+                Y[82 + 1],
+                Y[210],
+                Y[210 + 1],
+                (double) -0.427555093430282, (double) +0.903989293123443);
+  BUTTERFLY_XY (Y[84],               /* W42 */
+                Y[84 + 1],
+                Y[212],
+                Y[212 + 1],
+                Y[84],
+                Y[84 + 1],
+                Y[212],
+                Y[212 + 1],
+                (double) -0.471396736825998, (double) +0.881921264348355);
+  BUTTERFLY_XY (Y[86],               /* W43 */
+                Y[86 + 1],
+                Y[214],
+                Y[214 + 1],
+                Y[86],
+                Y[86 + 1],
+                Y[214],
+                Y[214 + 1],
+                (double) -0.514102744193222, (double) +0.857728610000272);
+  BUTTERFLY_XY (Y[88],               /* W44 */
+                Y[88 + 1],
+                Y[216],
+                Y[216 + 1],
+                Y[88],
+                Y[88 + 1],
+                Y[216],
+                Y[216 + 1],
+                (double) -0.555570233019602, (double) +0.831469612302545);
+  BUTTERFLY_XY (Y[90],               /* W45 */
+                Y[90 + 1],
+                Y[218],
+                Y[218 + 1],
+                Y[90],
+                Y[90 + 1],
+                Y[218],
+                Y[218 + 1],
+                (double) -0.595699304492433, (double) +0.803207531480645);
+  BUTTERFLY_XY (Y[92],               /* W46 */
+                Y[92 + 1],
+                Y[220],
+                Y[220 + 1],
+                Y[92],
+                Y[92 + 1],
+                Y[220],
+                Y[220 + 1],
+                (double) -0.634393284163645, (double) +0.773010453362737);
+  BUTTERFLY_XY (Y[94],               /* W47 */
+                Y[94 + 1],
+                Y[222],
+                Y[222 + 1],
+                Y[94],
+                Y[94 + 1],
+                Y[222],
+                Y[222 + 1],
+                (double) -0.671558954847018, (double) +0.740951125354959);
+  BUTTERFLY_yY (Y[96],               /* W48 */
+                Y[96 + 1],
+                Y[224],
+                Y[224 + 1],
+                Y[96],
+                Y[96 + 1],
+                Y[224],
+                Y[224 + 1],
+                (double) -0.707106781186547, (double) +0.707106781186548);
+  BUTTERFLY_XY (Y[98],               /* W49 */
+                Y[98 + 1],
+                Y[226],
+                Y[226 + 1],
+                Y[98],
+                Y[98 + 1],
+                Y[226],
+                Y[226 + 1],
+                (double) -0.740951125354959, (double) +0.671558954847019);
+  BUTTERFLY_XY (Y[100],               /* W50 */
+                Y[100 + 1],
+                Y[228],
+                Y[228 + 1],
+                Y[100],
+                Y[100 + 1],
+                Y[228],
+                Y[228 + 1],
+                (double) -0.773010453362737, (double) +0.634393284163645);
+  BUTTERFLY_XY (Y[102],               /* W51 */
+                Y[102 + 1],
+                Y[230],
+                Y[230 + 1],
+                Y[102],
+                Y[102 + 1],
+                Y[230],
+                Y[230 + 1],
+                (double) -0.803207531480645, (double) +0.595699304492433);
+  BUTTERFLY_XY (Y[104],               /* W52 */
+                Y[104 + 1],
+                Y[232],
+                Y[232 + 1],
+                Y[104],
+                Y[104 + 1],
+                Y[232],
+                Y[232 + 1],
+                (double) -0.831469612302545, (double) +0.555570233019602);
+  BUTTERFLY_XY (Y[106],               /* W53 */
+                Y[106 + 1],
+                Y[234],
+                Y[234 + 1],
+                Y[106],
+                Y[106 + 1],
+                Y[234],
+                Y[234 + 1],
+                (double) -0.857728610000272, (double) +0.514102744193222);
+  BUTTERFLY_XY (Y[108],               /* W54 */
+                Y[108 + 1],
+                Y[236],
+                Y[236 + 1],
+                Y[108],
+                Y[108 + 1],
+                Y[236],
+                Y[236 + 1],
+                (double) -0.881921264348355, (double) +0.471396736825998);
+  BUTTERFLY_XY (Y[110],               /* W55 */
+                Y[110 + 1],
+                Y[238],
+                Y[238 + 1],
+                Y[110],
+                Y[110 + 1],
+                Y[238],
+                Y[238 + 1],
+                (double) -0.903989293123443, (double) +0.427555093430282);
+  BUTTERFLY_XY (Y[112],               /* W56 */
+                Y[112 + 1],
+                Y[240],
+                Y[240 + 1],
+                Y[112],
+                Y[112 + 1],
+                Y[240],
+                Y[240 + 1],
+                (double) -0.923879532511287, (double) +0.382683432365090);
+  BUTTERFLY_XY (Y[114],               /* W57 */
+                Y[114 + 1],
+                Y[242],
+                Y[242 + 1],
+                Y[114],
+                Y[114 + 1],
+                Y[242],
+                Y[242 + 1],
+                (double) -0.941544065183021, (double) +0.336889853392220);
+  BUTTERFLY_XY (Y[116],               /* W58 */
+                Y[116 + 1],
+                Y[244],
+                Y[244 + 1],
+                Y[116],
+                Y[116 + 1],
+                Y[244],
+                Y[244 + 1],
+                (double) -0.956940335732209, (double) +0.290284677254462);
+  BUTTERFLY_XY (Y[118],               /* W59 */
+                Y[118 + 1],
+                Y[246],
+                Y[246 + 1],
+                Y[118],
+                Y[118 + 1],
+                Y[246],
+                Y[246 + 1],
+                (double) -0.970031253194544, (double) +0.242980179903264);
+  BUTTERFLY_XY (Y[120],               /* W60 */
+                Y[120 + 1],
+                Y[248],
+                Y[248 + 1],
+                Y[120],
+                Y[120 + 1],
+                Y[248],
+                Y[248 + 1],
+                (double) -0.980785280403230, (double) +0.195090322016129);
+  BUTTERFLY_XY (Y[122],               /* W61 */
+                Y[122 + 1],
+                Y[250],
+                Y[250 + 1],
+                Y[122],
+                Y[122 + 1],
+                Y[250],
+                Y[250 + 1],
+                (double) -0.989176509964781, (double) +0.146730474455362);
+  BUTTERFLY_XY (Y[124],               /* W62 */
+                Y[124 + 1],
+                Y[252],
+                Y[252 + 1],
+                Y[124],
+                Y[124 + 1],
+                Y[252],
+                Y[252 + 1],
+                (double) -0.995184726672197, (double) +0.098017140329561);
+  BUTTERFLY_XY (Y[126],               /* W63 */
+                Y[126 + 1],
+                Y[254],
+                Y[254 + 1],
+                Y[126],
+                Y[126 + 1],
+                Y[254],
+                Y[254 + 1],
+                (double) -0.998795456205172, (double) +0.049067674327418);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 128 L S S S S S X)
+ **/
+static void
+gsl_power2_fft128analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2analysis (128, X, Y);
+
+  /* skipping 32 times fft4 */
+
+  /* skipping 16 times fft8 */
+
+  /* skipping 8 times fft16 */
+
+  /* skipping 4 times fft32 */
+
+  /* skipping 2 times fft64 */
+
+  /* perform 1 times fft128 */
+  gsl_power2_fft128analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 256 S S S S S S X T)
+ **/
+static void
+gsl_power2_fft256analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 128 times fft2 */
+
+  /* skipping 64 times fft4 */
+
+  /* skipping 32 times fft8 */
+
+  /* skipping 16 times fft16 */
+
+  /* skipping 8 times fft32 */
+
+  /* skipping 4 times fft64 */
+
+  /* perform 2 times fft128 */
+  gsl_power2_fft128analysis_skip2 (X, Y);
+  gsl_power2_fft128analysis_skip2 (X + 256, Y + 256);
+
+  /* perform 1 times fft256 */
+  {
+    static const double Wconst256[] = {
+      +0.999698818696204, +0.024541228522912,
+      +0.998795456205172, +0.049067674327418,
+      +0.997290456678690, +0.073564563599667,
+      +0.995184726672197, +0.098017140329561,
+      +0.992479534598710, +0.122410675199216,
+      +0.989176509964781, +0.146730474455362,
+      +0.985277642388941, +0.170961888760301,
+      +0.980785280403230, +0.195090322016128,
+      +0.975702130038529, +0.219101240156870,
+      +0.970031253194544, +0.242980179903264,
+      +0.963776065795440, +0.266712757474898,
+      +0.956940335732209, +0.290284677254462,
+      +0.949528180593037, +0.313681740398892,
+      +0.941544065183021, +0.336889853392220,
+      +0.932992798834739, +0.359895036534988,
+      +0.923879532511287, +0.382683432365090,
+      +0.914209755703531, +0.405241314004990,
+      +0.903989293123443, +0.427555093430282,
+      +0.893224301195515, +0.449611329654607,
+      +0.881921264348355, +0.471396736825998,
+      +0.870086991108711, +0.492898192229784,
+      +0.857728610000272, +0.514102744193222,
+      +0.844853565249707, +0.534997619887097,
+      +0.831469612302545, +0.555570233019602,
+      +0.817584813151584, +0.575808191417845,
+      +0.803207531480645, +0.595699304492433,
+      +0.788346427626606, +0.615231590580627,
+      +0.773010453362737, +0.634393284163645,
+      +0.757208846506485, +0.653172842953777,
+      +0.740951125354959, +0.671558954847018,
+      +0.724247082951467, +0.689540544737067,
+      +0.707106781186548, +0.707106781186547,
+      +0.689540544737067, +0.724247082951467,
+      +0.671558954847018, +0.740951125354959,
+      +0.653172842953777, +0.757208846506484,
+      +0.634393284163645, +0.773010453362737,
+      +0.615231590580627, +0.788346427626606,
+      +0.595699304492433, +0.803207531480645,
+      +0.575808191417845, +0.817584813151584,
+      +0.555570233019602, +0.831469612302545,
+      +0.534997619887097, +0.844853565249707,
+      +0.514102744193222, +0.857728610000272,
+      +0.492898192229784, +0.870086991108711,
+      +0.471396736825998, +0.881921264348355,
+      +0.449611329654607, +0.893224301195515,
+      +0.427555093430282, +0.903989293123443,
+      +0.405241314004990, +0.914209755703531,
+      +0.382683432365090, +0.923879532511287,
+      +0.359895036534988, +0.932992798834739,
+      +0.336889853392220, +0.941544065183021,
+      +0.313681740398892, +0.949528180593037,
+      +0.290284677254462, +0.956940335732209,
+      +0.266712757474898, +0.963776065795440,
+      +0.242980179903264, +0.970031253194544,
+      +0.219101240156870, +0.975702130038529,
+      +0.195090322016128, +0.980785280403230,
+      +0.170961888760301, +0.985277642388941,
+      +0.146730474455362, +0.989176509964781,
+      +0.122410675199216, +0.992479534598710,
+      +0.098017140329561, +0.995184726672197,
+      +0.073564563599667, +0.997290456678690,
+      +0.049067674327418, +0.998795456205172,
+      +0.024541228522912, +0.999698818696204,
+    };
+    const double *W = Wconst256 - 2;
+    double *Z = Y + 128;
+    for (offset = 0; offset < 512; offset += 512) {
+      BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                    Y[offset + 256], Y[offset + 256 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 256], Y[offset + 256 + 1],
+                    __1, __0);
+      BUTTERFLY_01 (Z[offset], Z[offset + 1],
+                    Z[offset + 256], Z[offset + 256 + 1],
+                    Z[offset], Z[offset + 1],
+                    Z[offset + 256], Z[offset + 256 + 1],
+                    __0, __1);
+    }
+    for (butterfly = 2; butterfly < 128; butterfly += 2) {
+      Wre = W[butterfly]; Wim = W[butterfly + 1];
+      for (block = 0; block < 512; block += 512) {
+        offset = butterfly + block;
+        BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                      Y[offset + 256], Y[offset + 256 + 1],
+                      Y[offset], Y[offset + 1],
+                      Y[offset + 256], Y[offset + 256 + 1],
+                      Wre, Wim);
+        BUTTERFLY_Yx (Z[offset], Z[offset + 1],
+                      Z[offset + 256], Z[offset + 256 + 1],
+                      Z[offset], Z[offset + 1],
+                      Z[offset + 256], Z[offset + 256 + 1],
+                      Wre, Wim);
+      }
+    }
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 256 L S S S S S S X)
+ **/
+static void
+gsl_power2_fft256analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2analysis (256, X, Y);
+
+  /* skipping 64 times fft4 */
+
+  /* skipping 32 times fft8 */
+
+  /* skipping 16 times fft16 */
+
+  /* skipping 8 times fft32 */
+
+  /* skipping 4 times fft64 */
+
+  /* skipping 2 times fft128 */
+
+  /* perform 1 times fft256 */
+  gsl_power2_fft256analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 512 S S S S S S X T T)
+ **/
+static void
+gsl_power2_fft512analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 256 times fft2 */
+
+  /* skipping 128 times fft4 */
+
+  /* skipping 64 times fft8 */
+
+  /* skipping 32 times fft16 */
+
+  /* skipping 16 times fft32 */
+
+  /* skipping 8 times fft64 */
+
+  /* perform 4 times fft128 */
+  gsl_power2_fft128analysis_skip2 (X, Y);
+  gsl_power2_fft128analysis_skip2 (X + 256, Y + 256);
+  gsl_power2_fft128analysis_skip2 (X + 512, Y + 512);
+  gsl_power2_fft128analysis_skip2 (X + 768, Y + 768);
+
+  /* perform 2 times fft256 */
+  {
+    static const double Wconst256[] = {
+      +0.999698818696204, +0.024541228522912,
+      +0.998795456205172, +0.049067674327418,
+      +0.997290456678690, +0.073564563599667,
+      +0.995184726672197, +0.098017140329561,
+      +0.992479534598710, +0.122410675199216,
+      +0.989176509964781, +0.146730474455362,
+      +0.985277642388941, +0.170961888760301,
+      +0.980785280403230, +0.195090322016128,
+      +0.975702130038529, +0.219101240156870,
+      +0.970031253194544, +0.242980179903264,
+      +0.963776065795440, +0.266712757474898,
+      +0.956940335732209, +0.290284677254462,
+      +0.949528180593037, +0.313681740398892,
+      +0.941544065183021, +0.336889853392220,
+      +0.932992798834739, +0.359895036534988,
+      +0.923879532511287, +0.382683432365090,
+      +0.914209755703531, +0.405241314004990,
+      +0.903989293123443, +0.427555093430282,
+      +0.893224301195515, +0.449611329654607,
+      +0.881921264348355, +0.471396736825998,
+      +0.870086991108711, +0.492898192229784,
+      +0.857728610000272, +0.514102744193222,
+      +0.844853565249707, +0.534997619887097,
+      +0.831469612302545, +0.555570233019602,
+      +0.817584813151584, +0.575808191417845,
+      +0.803207531480645, +0.595699304492433,
+      +0.788346427626606, +0.615231590580627,
+      +0.773010453362737, +0.634393284163645,
+      +0.757208846506485, +0.653172842953777,
+      +0.740951125354959, +0.671558954847018,
+      +0.724247082951467, +0.689540544737067,
+      +0.707106781186548, +0.707106781186547,
+      +0.689540544737067, +0.724247082951467,
+      +0.671558954847018, +0.740951125354959,
+      +0.653172842953777, +0.757208846506484,
+      +0.634393284163645, +0.773010453362737,
+      +0.615231590580627, +0.788346427626606,
+      +0.595699304492433, +0.803207531480645,
+      +0.575808191417845, +0.817584813151584,
+      +0.555570233019602, +0.831469612302545,
+      +0.534997619887097, +0.844853565249707,
+      +0.514102744193222, +0.857728610000272,
+      +0.492898192229784, +0.870086991108711,
+      +0.471396736825998, +0.881921264348355,
+      +0.449611329654607, +0.893224301195515,
+      +0.427555093430282, +0.903989293123443,
+      +0.405241314004990, +0.914209755703531,
+      +0.382683432365090, +0.923879532511287,
+      +0.359895036534988, +0.932992798834739,
+      +0.336889853392220, +0.941544065183021,
+      +0.313681740398892, +0.949528180593037,
+      +0.290284677254462, +0.956940335732209,
+      +0.266712757474898, +0.963776065795440,
+      +0.242980179903264, +0.970031253194544,
+      +0.219101240156870, +0.975702130038529,
+      +0.195090322016128, +0.980785280403230,
+      +0.170961888760301, +0.985277642388941,
+      +0.146730474455362, +0.989176509964781,
+      +0.122410675199216, +0.992479534598710,
+      +0.098017140329561, +0.995184726672197,
+      +0.073564563599667, +0.997290456678690,
+      +0.049067674327418, +0.998795456205172,
+      +0.024541228522912, +0.999698818696204,
+    };
+    const double *W = Wconst256 - 2;
+    double *Z = Y + 128;
+    for (offset = 0; offset < 1024; offset += 512) {
+      BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                    Y[offset + 256], Y[offset + 256 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 256], Y[offset + 256 + 1],
+                    __1, __0);
+      BUTTERFLY_01 (Z[offset], Z[offset + 1],
+                    Z[offset + 256], Z[offset + 256 + 1],
+                    Z[offset], Z[offset + 1],
+                    Z[offset + 256], Z[offset + 256 + 1],
+                    __0, __1);
+    }
+    for (butterfly = 2; butterfly < 128; butterfly += 2) {
+      Wre = W[butterfly]; Wim = W[butterfly + 1];
+      for (block = 0; block < 1024; block += 512) {
+        offset = butterfly + block;
+        BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                      Y[offset + 256], Y[offset + 256 + 1],
+                      Y[offset], Y[offset + 1],
+                      Y[offset + 256], Y[offset + 256 + 1],
+                      Wre, Wim);
+        BUTTERFLY_Yx (Z[offset], Z[offset + 1],
+                      Z[offset + 256], Z[offset + 256 + 1],
+                      Z[offset], Z[offset + 1],
+                      Z[offset + 256], Z[offset + 256 + 1],
+                      Wre, Wim);
+      }
+    }
+  }
+
+  /* perform 1 times fft512 */
+  {
+    static const double Wconst512[] = {
+      +0.999924701839145, +0.012271538285720,
+      +0.999698818696204, +0.024541228522912,
+      +0.999322384588350, +0.036807222941359,
+      +0.998795456205172, +0.049067674327418,
+      +0.998118112900149, +0.061320736302209,
+      +0.997290456678690, +0.073564563599667,
+      +0.996312612182778, +0.085797312344440,
+      +0.995184726672197, +0.098017140329561,
+      +0.993906970002356, +0.110222207293883,
+      +0.992479534598710, +0.122410675199216,
+      +0.990902635427780, +0.134580708507126,
+      +0.989176509964781, +0.146730474455362,
+      +0.987301418157858, +0.158858143333861,
+      +0.985277642388941, +0.170961888760301,
+      +0.983105487431216, +0.183039887955141,
+      +0.980785280403230, +0.195090322016128,
+      +0.978317370719628, +0.207111376192219,
+      +0.975702130038529, +0.219101240156870,
+      +0.972939952205560, +0.231058108280671,
+      +0.970031253194544, +0.242980179903264,
+      +0.966976471044852, +0.254865659604515,
+      +0.963776065795440, +0.266712757474898,
+      +0.960430519415566, +0.278519689385053,
+      +0.956940335732209, +0.290284677254462,
+      +0.953306040354194, +0.302005949319228,
+      +0.949528180593037, +0.313681740398892,
+      +0.945607325380521, +0.325310292162263,
+      +0.941544065183021, +0.336889853392220,
+      +0.937339011912575, +0.348418680249435,
+      +0.932992798834739, +0.359895036534988,
+      +0.928506080473216, +0.371317193951838,
+      +0.923879532511287, +0.382683432365090,
+      +0.919113851690058, +0.393992040061048,
+      +0.914209755703531, +0.405241314004990,
+      +0.909167983090522, +0.416429560097637,
+      +0.903989293123443, +0.427555093430282,
+      +0.898674465693954, +0.438616238538528,
+      +0.893224301195515, +0.449611329654607,
+      +0.887639620402854, +0.460538710958240,
+      +0.881921264348355, +0.471396736825998,
+      +0.876070094195407, +0.482183772079123,
+      +0.870086991108711, +0.492898192229784,
+      +0.863972856121587, +0.503538383725718,
+      +0.857728610000272, +0.514102744193222,
+      +0.851355193105265, +0.524589682678469,
+      +0.844853565249707, +0.534997619887097,
+      +0.838224705554838, +0.545324988422046,
+      +0.831469612302545, +0.555570233019602,
+      +0.824589302785025, +0.565731810783613,
+      +0.817584813151584, +0.575808191417845,
+      +0.810457198252595, +0.585797857456439,
+      +0.803207531480645, +0.595699304492433,
+      +0.795836904608884, +0.605511041404326,
+      +0.788346427626606, +0.615231590580627,
+      +0.780737228572094, +0.624859488142386,
+      +0.773010453362737, +0.634393284163645,
+      +0.765167265622459, +0.643831542889791,
+      +0.757208846506485, +0.653172842953777,
+      +0.749136394523459, +0.662415777590172,
+      +0.740951125354959, +0.671558954847018,
+      +0.732654271672413, +0.680600997795453,
+      +0.724247082951467, +0.689540544737067,
+      +0.715730825283819, +0.698376249408973,
+      +0.707106781186548, +0.707106781186547,
+      +0.698376249408973, +0.715730825283819,
+      +0.689540544737067, +0.724247082951467,
+      +0.680600997795453, +0.732654271672413,
+      +0.671558954847018, +0.740951125354959,
+      +0.662415777590172, +0.749136394523459,
+      +0.653172842953777, +0.757208846506484,
+      +0.643831542889791, +0.765167265622459,
+      +0.634393284163645, +0.773010453362737,
+      +0.624859488142386, +0.780737228572094,
+      +0.615231590580627, +0.788346427626606,
+      +0.605511041404326, +0.795836904608883,
+      +0.595699304492433, +0.803207531480645,
+      +0.585797857456439, +0.810457198252595,
+      +0.575808191417845, +0.817584813151584,
+      +0.565731810783613, +0.824589302785025,
+      +0.555570233019602, +0.831469612302545,
+      +0.545324988422046, +0.838224705554838,
+      +0.534997619887097, +0.844853565249707,
+      +0.524589682678469, +0.851355193105265,
+      +0.514102744193222, +0.857728610000272,
+      +0.503538383725718, +0.863972856121587,
+      +0.492898192229784, +0.870086991108711,
+      +0.482183772079123, +0.876070094195407,
+      +0.471396736825998, +0.881921264348355,
+      +0.460538710958240, +0.887639620402854,
+      +0.449611329654607, +0.893224301195515,
+      +0.438616238538528, +0.898674465693954,
+      +0.427555093430282, +0.903989293123443,
+      +0.416429560097637, +0.909167983090522,
+      +0.405241314004990, +0.914209755703531,
+      +0.393992040061048, +0.919113851690058,
+      +0.382683432365090, +0.923879532511287,
+      +0.371317193951838, +0.928506080473215,
+      +0.359895036534988, +0.932992798834739,
+      +0.348418680249435, +0.937339011912575,
+      +0.336889853392220, +0.941544065183021,
+      +0.325310292162263, +0.945607325380521,
+      +0.313681740398892, +0.949528180593037,
+      +0.302005949319228, +0.953306040354194,
+      +0.290284677254462, +0.956940335732209,
+      +0.278519689385053, +0.960430519415566,
+      +0.266712757474898, +0.963776065795440,
+      +0.254865659604515, +0.966976471044852,
+      +0.242980179903264, +0.970031253194544,
+      +0.231058108280671, +0.972939952205560,
+      +0.219101240156870, +0.975702130038529,
+      +0.207111376192219, +0.978317370719628,
+      +0.195090322016128, +0.980785280403230,
+      +0.183039887955141, +0.983105487431216,
+      +0.170961888760301, +0.985277642388941,
+      +0.158858143333861, +0.987301418157858,
+      +0.146730474455362, +0.989176509964781,
+      +0.134580708507126, +0.990902635427780,
+      +0.122410675199216, +0.992479534598710,
+      +0.110222207293883, +0.993906970002356,
+      +0.098017140329561, +0.995184726672197,
+      +0.085797312344440, +0.996312612182778,
+      +0.073564563599667, +0.997290456678690,
+      +0.061320736302209, +0.998118112900149,
+      +0.049067674327418, +0.998795456205172,
+      +0.036807222941359, +0.999322384588350,
+      +0.024541228522912, +0.999698818696204,
+      +0.012271538285720, +0.999924701839145,
+    };
+    const double *W = Wconst512 - 2;
+    double *Z = Y + 256;
+    for (offset = 0; offset < 1024; offset += 1024) {
+      BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                    Y[offset + 512], Y[offset + 512 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 512], Y[offset + 512 + 1],
+                    __1, __0);
+      BUTTERFLY_01 (Z[offset], Z[offset + 1],
+                    Z[offset + 512], Z[offset + 512 + 1],
+                    Z[offset], Z[offset + 1],
+                    Z[offset + 512], Z[offset + 512 + 1],
+                    __0, __1);
+    }
+    for (butterfly = 2; butterfly < 256; butterfly += 2) {
+      Wre = W[butterfly]; Wim = W[butterfly + 1];
+      for (block = 0; block < 1024; block += 1024) {
+        offset = butterfly + block;
+        BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                      Y[offset + 512], Y[offset + 512 + 1],
+                      Y[offset], Y[offset + 1],
+                      Y[offset + 512], Y[offset + 512 + 1],
+                      Wre, Wim);
+        BUTTERFLY_Yx (Z[offset], Z[offset + 1],
+                      Z[offset + 512], Z[offset + 512 + 1],
+                      Z[offset], Z[offset + 1],
+                      Z[offset + 512], Z[offset + 512 + 1],
+                      Wre, Wim);
+      }
+    }
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 512 L S S S S S S S X)
+ **/
+static void
+gsl_power2_fft512analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2analysis (512, X, Y);
+
+  /* skipping 128 times fft4 */
+
+  /* skipping 64 times fft8 */
+
+  /* skipping 32 times fft16 */
+
+  /* skipping 16 times fft32 */
+
+  /* skipping 8 times fft64 */
+
+  /* skipping 4 times fft128 */
+
+  /* skipping 2 times fft256 */
+
+  /* perform 1 times fft512 */
+  gsl_power2_fft512analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 1024 S S S S S S S S X L)
+ **/
+static void
+gsl_power2_fft1024analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 512 times fft2 */
+
+  /* skipping 256 times fft4 */
+
+  /* skipping 128 times fft8 */
+
+  /* skipping 64 times fft16 */
+
+  /* skipping 32 times fft32 */
+
+  /* skipping 16 times fft64 */
+
+  /* skipping 8 times fft128 */
+
+  /* skipping 4 times fft256 */
+
+  /* perform 2 times fft512 */
+  gsl_power2_fft512analysis_skip2 (X, Y);
+  gsl_power2_fft512analysis_skip2 (X + 1024, Y + 1024);
+
+  /* perform 1 times fft1024 */
+  for (offset = 0; offset < 2048; offset += 2048) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999981175282601; Wim = +0.006135884649154;
+  for (butterfly = 2; butterfly < 512; butterfly += 2) {
+    for (block = 0; block < 2048; block += 2048) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000018824717399, +0.006135884649154);
+  }
+  for (offset = 512; offset < 2048; offset += 2048) {
+    BUTTERFLY_01 (Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  __0, __1);
+  }
+  Wre = -0.006135884649154; Wim = +0.999981175282601;
+  for (butterfly = 514; butterfly < 1024; butterfly += 2) {
+    for (block = 0; block < 2048; block += 2048) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000018824717399, +0.006135884649154);
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 1024 L S S S S S S S S X)
+ **/
+static void
+gsl_power2_fft1024analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2analysis (1024, X, Y);
+
+  /* skipping 256 times fft4 */
+
+  /* skipping 128 times fft8 */
+
+  /* skipping 64 times fft16 */
+
+  /* skipping 32 times fft32 */
+
+  /* skipping 16 times fft64 */
+
+  /* skipping 8 times fft128 */
+
+  /* skipping 4 times fft256 */
+
+  /* skipping 2 times fft512 */
+
+  /* perform 1 times fft1024 */
+  gsl_power2_fft1024analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 2048 S S S S S S S S X L L)
+ **/
+static void
+gsl_power2_fft2048analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 1024 times fft2 */
+
+  /* skipping 512 times fft4 */
+
+  /* skipping 256 times fft8 */
+
+  /* skipping 128 times fft16 */
+
+  /* skipping 64 times fft32 */
+
+  /* skipping 32 times fft64 */
+
+  /* skipping 16 times fft128 */
+
+  /* skipping 8 times fft256 */
+
+  /* perform 4 times fft512 */
+  gsl_power2_fft512analysis_skip2 (X, Y);
+  gsl_power2_fft512analysis_skip2 (X + 1024, Y + 1024);
+  gsl_power2_fft512analysis_skip2 (X + 2048, Y + 2048);
+  gsl_power2_fft512analysis_skip2 (X + 3072, Y + 3072);
+
+  /* perform 2 times fft1024 */
+  for (offset = 0; offset < 4096; offset += 2048) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999981175282601; Wim = +0.006135884649154;
+  for (butterfly = 2; butterfly < 512; butterfly += 2) {
+    for (block = 0; block < 4096; block += 2048) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000018824717399, +0.006135884649154);
+  }
+  for (offset = 512; offset < 4096; offset += 2048) {
+    BUTTERFLY_01 (Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  __0, __1);
+  }
+  Wre = -0.006135884649154; Wim = +0.999981175282601;
+  for (butterfly = 514; butterfly < 1024; butterfly += 2) {
+    for (block = 0; block < 4096; block += 2048) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000018824717399, +0.006135884649154);
+  }
+
+  /* perform 1 times fft2048 */
+  for (offset = 0; offset < 4096; offset += 4096) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 2048], Y[offset + 2048 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 2048], Y[offset + 2048 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999995293809576; Wim = +0.003067956762966;
+  for (butterfly = 2; butterfly < 1024; butterfly += 2) {
+    for (block = 0; block < 4096; block += 4096) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 2048], Y[offset + 2048 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 2048], Y[offset + 2048 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000004706190424, +0.003067956762966);
+  }
+  for (offset = 1024; offset < 4096; offset += 4096) {
+    BUTTERFLY_01 (Y[offset], Y[offset + 1],
+                  Y[offset + 2048], Y[offset + 2048 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 2048], Y[offset + 2048 + 1],
+                  __0, __1);
+  }
+  Wre = -0.003067956762966; Wim = +0.999995293809576;
+  for (butterfly = 1026; butterfly < 2048; butterfly += 2) {
+    for (block = 0; block < 4096; block += 4096) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 2048], Y[offset + 2048 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 2048], Y[offset + 2048 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000004706190424, +0.003067956762966);
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 2048 L S S S S S S S S S X)
+ **/
+static void
+gsl_power2_fft2048analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2analysis (2048, X, Y);
+
+  /* skipping 512 times fft4 */
+
+  /* skipping 256 times fft8 */
+
+  /* skipping 128 times fft16 */
+
+  /* skipping 64 times fft32 */
+
+  /* skipping 32 times fft64 */
+
+  /* skipping 16 times fft128 */
+
+  /* skipping 8 times fft256 */
+
+  /* skipping 4 times fft512 */
+
+  /* skipping 2 times fft1024 */
+
+  /* perform 1 times fft2048 */
+  gsl_power2_fft2048analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 4096 S S S S S S S S S S X L)
+ **/
+static void
+gsl_power2_fft4096analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 2048 times fft2 */
+
+  /* skipping 1024 times fft4 */
+
+  /* skipping 512 times fft8 */
+
+  /* skipping 256 times fft16 */
+
+  /* skipping 128 times fft32 */
+
+  /* skipping 64 times fft64 */
+
+  /* skipping 32 times fft128 */
+
+  /* skipping 16 times fft256 */
+
+  /* skipping 8 times fft512 */
+
+  /* skipping 4 times fft1024 */
+
+  /* perform 2 times fft2048 */
+  gsl_power2_fft2048analysis_skip2 (X, Y);
+  gsl_power2_fft2048analysis_skip2 (X + 4096, Y + 4096);
+
+  /* perform 1 times fft4096 */
+  for (offset = 0; offset < 8192; offset += 8192) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 4096], Y[offset + 4096 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 4096], Y[offset + 4096 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999998823451702; Wim = +0.001533980186285;
+  for (butterfly = 2; butterfly < 2048; butterfly += 2) {
+    for (block = 0; block < 8192; block += 8192) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 4096], Y[offset + 4096 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 4096], Y[offset + 4096 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000001176548298, +0.001533980186285);
+  }
+  for (offset = 2048; offset < 8192; offset += 8192) {
+    BUTTERFLY_01 (Y[offset], Y[offset + 1],
+                  Y[offset + 4096], Y[offset + 4096 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 4096], Y[offset + 4096 + 1],
+                  __0, __1);
+  }
+  Wre = -0.001533980186285; Wim = +0.999998823451702;
+  for (butterfly = 2050; butterfly < 4096; butterfly += 2) {
+    for (block = 0; block < 8192; block += 8192) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 4096], Y[offset + 4096 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 4096], Y[offset + 4096 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000001176548298, +0.001533980186285);
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 4096 L S S S S S S S S S S X)
+ **/
+static void
+gsl_power2_fft4096analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2analysis (4096, X, Y);
+
+  /* skipping 1024 times fft4 */
+
+  /* skipping 512 times fft8 */
+
+  /* skipping 256 times fft16 */
+
+  /* skipping 128 times fft32 */
+
+  /* skipping 64 times fft64 */
+
+  /* skipping 32 times fft128 */
+
+  /* skipping 16 times fft256 */
+
+  /* skipping 8 times fft512 */
+
+  /* skipping 4 times fft1024 */
+
+  /* skipping 2 times fft2048 */
+
+  /* perform 1 times fft4096 */
+  gsl_power2_fft4096analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 8192 S S S S S S S S S S S X L)
+ **/
+static void
+gsl_power2_fft8192analysis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 4096 times fft2 */
+
+  /* skipping 2048 times fft4 */
+
+  /* skipping 1024 times fft8 */
+
+  /* skipping 512 times fft16 */
+
+  /* skipping 256 times fft32 */
+
+  /* skipping 128 times fft64 */
+
+  /* skipping 64 times fft128 */
+
+  /* skipping 32 times fft256 */
+
+  /* skipping 16 times fft512 */
+
+  /* skipping 8 times fft1024 */
+
+  /* skipping 4 times fft2048 */
+
+  /* perform 2 times fft4096 */
+  gsl_power2_fft4096analysis_skip2 (X, Y);
+  gsl_power2_fft4096analysis_skip2 (X + 8192, Y + 8192);
+
+  /* perform 1 times fft8192 */
+  for (offset = 0; offset < 16384; offset += 16384) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 8192], Y[offset + 8192 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 8192], Y[offset + 8192 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999999705862882; Wim = +0.000766990318743;
+  for (butterfly = 2; butterfly < 4096; butterfly += 2) {
+    for (block = 0; block < 16384; block += 16384) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 8192], Y[offset + 8192 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 8192], Y[offset + 8192 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000000294137118, +0.000766990318743);
+  }
+  for (offset = 4096; offset < 16384; offset += 16384) {
+    BUTTERFLY_01 (Y[offset], Y[offset + 1],
+                  Y[offset + 8192], Y[offset + 8192 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 8192], Y[offset + 8192 + 1],
+                  __0, __1);
+  }
+  Wre = -0.000766990318743; Wim = +0.999999705862882;
+  for (butterfly = 4098; butterfly < 8192; butterfly += 2) {
+    for (block = 0; block < 16384; block += 16384) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 8192], Y[offset + 8192 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 8192], Y[offset + 8192 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000000294137118, +0.000766990318743);
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 8192 L S S S S S S S S S S S X)
+ **/
+static void
+gsl_power2_fft8192analysis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2analysis (8192, X, Y);
+
+  /* skipping 2048 times fft4 */
+
+  /* skipping 1024 times fft8 */
+
+  /* skipping 512 times fft16 */
+
+  /* skipping 256 times fft32 */
+
+  /* skipping 128 times fft64 */
+
+  /* skipping 64 times fft128 */
+
+  /* skipping 32 times fft256 */
+
+  /* skipping 16 times fft512 */
+
+  /* skipping 8 times fft1024 */
+
+  /* skipping 4 times fft2048 */
+
+  /* skipping 2 times fft4096 */
+
+  /* perform 1 times fft8192 */
+  gsl_power2_fft8192analysis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 2 F)
+ **/
+static void
+gsl_power2_fft2synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 1 times fft2 */
+  BUTTERFLY_10scale (X[0], X[0 + 1],
+                  X[2], X[2 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  1.0 / (double) 2);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 4 S F)
+ **/
+static void
+gsl_power2_fft4synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 2 times fft2 */
+
+  /* perform 1 times fft4 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_0m (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 4 F X)
+ **/
+static void
+gsl_power2_fft4synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 2 times fft2 */
+  BUTTERFLY_10scale (X[0], X[0 + 1],
+                  X[4], X[4 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  1.0 / (double) 4);
+  BUTTERFLY_10scale (X[2], X[2 + 1],
+                  X[6], X[6 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  1.0 / (double) 4);
+
+  /* perform 1 times fft4 */
+  gsl_power2_fft4synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 8 S F F)
+ **/
+static void
+gsl_power2_fft8synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 4 times fft2 */
+
+  /* perform 2 times fft4 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[8],               /* W0 */
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_0m (Y[2],               /* W2 */
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[10],               /* W2 */
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+
+  /* perform 1 times fft8 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_yY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_0m (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_XX (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 8 F S X)
+ **/
+static void
+gsl_power2_fft8synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 4 times fft2 */
+  BUTTERFLY_10scale (X[0], X[0 + 1],
+                  X[8], X[8 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  1.0 / (double) 8);
+  BUTTERFLY_10scale (X[4], X[4 + 1],
+                  X[12], X[12 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  1.0 / (double) 8);
+  BUTTERFLY_10scale (X[2], X[2 + 1],
+                  X[10], X[10 + 1],
+                  Y[8], Y[8 + 1],
+                  Y[10], Y[10 + 1],
+                  1.0 / (double) 8);
+  BUTTERFLY_10scale (X[6], X[6 + 1],
+                  X[14], X[14 + 1],
+                  Y[12], Y[12 + 1],
+                  Y[14], Y[14 + 1],
+                  1.0 / (double) 8);
+
+  /* skipping 2 times fft4 */
+
+  /* perform 1 times fft8 */
+  gsl_power2_fft8synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 16 S F F F)
+ **/
+static void
+gsl_power2_fft16synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 8 times fft2 */
+
+  /* perform 4 times fft4 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[8],               /* W0 */
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[16],               /* W0 */
+                Y[16 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[20],
+                Y[20 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[24],               /* W0 */
+                Y[24 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_0m (Y[2],               /* W4 */
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[10],               /* W4 */
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[18],               /* W4 */
+                Y[18 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[22],
+                Y[22 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[26],               /* W4 */
+                Y[26 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+
+  /* perform 2 times fft8 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[16],               /* W0 */
+                Y[16 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[24],
+                Y[24 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_yY (Y[2],               /* W2 */
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_yY (Y[18],               /* W2 */
+                Y[18 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[26],
+                Y[26 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_0m (Y[4],               /* W4 */
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[20],               /* W4 */
+                Y[20 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_XX (Y[6],               /* W6 */
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XX (Y[22],               /* W6 */
+                Y[22 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+
+  /* perform 1 times fft16 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[16],
+                Y[16 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[18],
+                Y[18 + 1],
+                (double) +0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_yY (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[20],
+                Y[20 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_XY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[22],
+                Y[22 + 1],
+                (double) +0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_0m (Y[8],               /* W4 */
+                Y[8 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[24],
+                Y[24 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_XY (Y[10],               /* W5 */
+                Y[10 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[26],
+                Y[26 + 1],
+                (double) -0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XX (Y[12],               /* W6 */
+                Y[12 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XY (Y[14],               /* W7 */
+                Y[14 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) -0.923879532511287, (double) -0.382683432365090);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 16 F S S X)
+ **/
+static void
+gsl_power2_fft16synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 8 times fft2 */
+  BUTTERFLY_10scale (X[0], X[0 + 1],
+                  X[16], X[16 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  1.0 / (double) 16);
+  BUTTERFLY_10scale (X[8], X[8 + 1],
+                  X[24], X[24 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  1.0 / (double) 16);
+  BUTTERFLY_10scale (X[4], X[4 + 1],
+                  X[20], X[20 + 1],
+                  Y[8], Y[8 + 1],
+                  Y[10], Y[10 + 1],
+                  1.0 / (double) 16);
+  BUTTERFLY_10scale (X[12], X[12 + 1],
+                  X[28], X[28 + 1],
+                  Y[12], Y[12 + 1],
+                  Y[14], Y[14 + 1],
+                  1.0 / (double) 16);
+  BUTTERFLY_10scale (X[2], X[2 + 1],
+                  X[18], X[18 + 1],
+                  Y[16], Y[16 + 1],
+                  Y[18], Y[18 + 1],
+                  1.0 / (double) 16);
+  BUTTERFLY_10scale (X[10], X[10 + 1],
+                  X[26], X[26 + 1],
+                  Y[20], Y[20 + 1],
+                  Y[22], Y[22 + 1],
+                  1.0 / (double) 16);
+  BUTTERFLY_10scale (X[6], X[6 + 1],
+                  X[22], X[22 + 1],
+                  Y[24], Y[24 + 1],
+                  Y[26], Y[26 + 1],
+                  1.0 / (double) 16);
+  BUTTERFLY_10scale (X[14], X[14 + 1],
+                  X[30], X[30 + 1],
+                  Y[28], Y[28 + 1],
+                  Y[30], Y[30 + 1],
+                  1.0 / (double) 16);
+
+  /* skipping 4 times fft4 */
+
+  /* skipping 2 times fft8 */
+
+  /* perform 1 times fft16 */
+  gsl_power2_fft16synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 32 S F F F F)
+ **/
+static void
+gsl_power2_fft32synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 16 times fft2 */
+
+  /* perform 8 times fft4 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[4],
+                Y[4 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[8],               /* W0 */
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[16],               /* W0 */
+                Y[16 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[20],
+                Y[20 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[24],               /* W0 */
+                Y[24 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[32],               /* W0 */
+                Y[32 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[36],
+                Y[36 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[40],               /* W0 */
+                Y[40 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[44],
+                Y[44 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[48],               /* W0 */
+                Y[48 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[52],
+                Y[52 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[56],               /* W0 */
+                Y[56 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[60],
+                Y[60 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_0m (Y[2],               /* W8 */
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[6],
+                Y[6 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[10],               /* W8 */
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[18],               /* W8 */
+                Y[18 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[22],
+                Y[22 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[26],               /* W8 */
+                Y[26 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[34],               /* W8 */
+                Y[34 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[38],
+                Y[38 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[42],               /* W8 */
+                Y[42 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[46],
+                Y[46 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[50],               /* W8 */
+                Y[50 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[54],
+                Y[54 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[58],               /* W8 */
+                Y[58 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[62],
+                Y[62 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+
+  /* perform 4 times fft8 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[8],
+                Y[8 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[16],               /* W0 */
+                Y[16 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[24],
+                Y[24 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[32],               /* W0 */
+                Y[32 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[40],
+                Y[40 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[48],               /* W0 */
+                Y[48 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[56],
+                Y[56 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_yY (Y[2],               /* W4 */
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[10],
+                Y[10 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_yY (Y[18],               /* W4 */
+                Y[18 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[26],
+                Y[26 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_yY (Y[34],               /* W4 */
+                Y[34 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[42],
+                Y[42 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_yY (Y[50],               /* W4 */
+                Y[50 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[58],
+                Y[58 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_0m (Y[4],               /* W8 */
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[12],
+                Y[12 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[20],               /* W8 */
+                Y[20 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[36],               /* W8 */
+                Y[36 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[44],
+                Y[44 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[52],               /* W8 */
+                Y[52 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[60],
+                Y[60 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_XX (Y[6],               /* W12 */
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[14],
+                Y[14 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XX (Y[22],               /* W12 */
+                Y[22 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XX (Y[38],               /* W12 */
+                Y[38 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[46],
+                Y[46 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XX (Y[54],               /* W12 */
+                Y[54 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[62],
+                Y[62 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+
+  /* perform 2 times fft16 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[16],
+                Y[16 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_10 (Y[32],               /* W0 */
+                Y[32 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[48],
+                Y[48 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W2 */
+                Y[2 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[18],
+                Y[18 + 1],
+                (double) +0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_XY (Y[34],               /* W2 */
+                Y[34 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[50],
+                Y[50 + 1],
+                (double) +0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_yY (Y[4],               /* W4 */
+                Y[4 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[20],
+                Y[20 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_yY (Y[36],               /* W4 */
+                Y[36 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[52],
+                Y[52 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_XY (Y[6],               /* W6 */
+                Y[6 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[22],
+                Y[22 + 1],
+                (double) +0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XY (Y[38],               /* W6 */
+                Y[38 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[54],
+                Y[54 + 1],
+                (double) +0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_0m (Y[8],               /* W8 */
+                Y[8 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[24],
+                Y[24 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_0m (Y[40],               /* W8 */
+                Y[40 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[56],
+                Y[56 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_XY (Y[10],               /* W10 */
+                Y[10 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[26],
+                Y[26 + 1],
+                (double) -0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XY (Y[42],               /* W10 */
+                Y[42 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[58],
+                Y[58 + 1],
+                (double) -0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XX (Y[12],               /* W12 */
+                Y[12 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[28],
+                Y[28 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XX (Y[44],               /* W12 */
+                Y[44 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[60],
+                Y[60 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XY (Y[14],               /* W14 */
+                Y[14 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[30],
+                Y[30 + 1],
+                (double) -0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_XY (Y[46],               /* W14 */
+                Y[46 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[62],
+                Y[62 + 1],
+                (double) -0.923879532511287, (double) -0.382683432365090);
+
+  /* perform 1 times fft32 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[32],
+                Y[32 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[34],
+                Y[34 + 1],
+                (double) +0.980785280403230, (double) -0.195090322016128);
+  BUTTERFLY_XY (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[36],
+                Y[36 + 1],
+                (double) +0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_XY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[38],
+                Y[38 + 1],
+                (double) +0.831469612302545, (double) -0.555570233019602);
+  BUTTERFLY_yY (Y[8],               /* W4 */
+                Y[8 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[40],
+                Y[40 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_XY (Y[10],               /* W5 */
+                Y[10 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[42],
+                Y[42 + 1],
+                (double) +0.555570233019602, (double) -0.831469612302545);
+  BUTTERFLY_XY (Y[12],               /* W6 */
+                Y[12 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[44],
+                Y[44 + 1],
+                (double) +0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XY (Y[14],               /* W7 */
+                Y[14 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[46],
+                Y[46 + 1],
+                (double) +0.195090322016128, (double) -0.980785280403230);
+  BUTTERFLY_0m (Y[16],               /* W8 */
+                Y[16 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[48],
+                Y[48 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_XY (Y[18],               /* W9 */
+                Y[18 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[50],
+                Y[50 + 1],
+                (double) -0.195090322016128, (double) -0.980785280403230);
+  BUTTERFLY_XY (Y[20],               /* W10 */
+                Y[20 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[52],
+                Y[52 + 1],
+                (double) -0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XY (Y[22],               /* W11 */
+                Y[22 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[54],
+                Y[54 + 1],
+                (double) -0.555570233019602, (double) -0.831469612302545);
+  BUTTERFLY_XX (Y[24],               /* W12 */
+                Y[24 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[56],
+                Y[56 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XY (Y[26],               /* W13 */
+                Y[26 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[58],
+                Y[58 + 1],
+                (double) -0.831469612302545, (double) -0.555570233019602);
+  BUTTERFLY_XY (Y[28],               /* W14 */
+                Y[28 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[60],
+                Y[60 + 1],
+                (double) -0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_XY (Y[30],               /* W15 */
+                Y[30 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[62],
+                Y[62 + 1],
+                (double) -0.980785280403230, (double) -0.195090322016129);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 32 F S S S X)
+ **/
+static void
+gsl_power2_fft32synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 16 times fft2 */
+  BUTTERFLY_10scale (X[0], X[0 + 1],
+                  X[32], X[32 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[16], X[16 + 1],
+                  X[48], X[48 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[8], X[8 + 1],
+                  X[40], X[40 + 1],
+                  Y[8], Y[8 + 1],
+                  Y[10], Y[10 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[24], X[24 + 1],
+                  X[56], X[56 + 1],
+                  Y[12], Y[12 + 1],
+                  Y[14], Y[14 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[4], X[4 + 1],
+                  X[36], X[36 + 1],
+                  Y[16], Y[16 + 1],
+                  Y[18], Y[18 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[20], X[20 + 1],
+                  X[52], X[52 + 1],
+                  Y[20], Y[20 + 1],
+                  Y[22], Y[22 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[12], X[12 + 1],
+                  X[44], X[44 + 1],
+                  Y[24], Y[24 + 1],
+                  Y[26], Y[26 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[28], X[28 + 1],
+                  X[60], X[60 + 1],
+                  Y[28], Y[28 + 1],
+                  Y[30], Y[30 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[2], X[2 + 1],
+                  X[34], X[34 + 1],
+                  Y[32], Y[32 + 1],
+                  Y[34], Y[34 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[18], X[18 + 1],
+                  X[50], X[50 + 1],
+                  Y[36], Y[36 + 1],
+                  Y[38], Y[38 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[10], X[10 + 1],
+                  X[42], X[42 + 1],
+                  Y[40], Y[40 + 1],
+                  Y[42], Y[42 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[26], X[26 + 1],
+                  X[58], X[58 + 1],
+                  Y[44], Y[44 + 1],
+                  Y[46], Y[46 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[6], X[6 + 1],
+                  X[38], X[38 + 1],
+                  Y[48], Y[48 + 1],
+                  Y[50], Y[50 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[22], X[22 + 1],
+                  X[54], X[54 + 1],
+                  Y[52], Y[52 + 1],
+                  Y[54], Y[54 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[14], X[14 + 1],
+                  X[46], X[46 + 1],
+                  Y[56], Y[56 + 1],
+                  Y[58], Y[58 + 1],
+                  1.0 / (double) 32);
+  BUTTERFLY_10scale (X[30], X[30 + 1],
+                  X[62], X[62 + 1],
+                  Y[60], Y[60 + 1],
+                  Y[62], Y[62 + 1],
+                  1.0 / (double) 32);
+
+  /* skipping 8 times fft4 */
+
+  /* skipping 4 times fft8 */
+
+  /* skipping 2 times fft16 */
+
+  /* perform 1 times fft32 */
+  gsl_power2_fft32synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 64 S R R R R F)
+ **/
+static void
+gsl_power2_fft64synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 32 times fft2 */
+
+  /* perform 16 times fft4 */
+  for (block = 0; block < 128; block += 8) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_0m (Y[block + 2],               /* W16 */
+                  Y[block + 2 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+  }
+
+  /* perform 8 times fft8 */
+  for (block = 0; block < 128; block += 16) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_yY (Y[block + 2],               /* W8 */
+                  Y[block + 2 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  (double) +0.707106781186548, (double) -0.707106781186547);
+    BUTTERFLY_0m (Y[block + 4],               /* W16 */
+                  Y[block + 4 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+    BUTTERFLY_XX (Y[block + 6],               /* W24 */
+                  Y[block + 6 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  (double) -0.707106781186547, (double) -0.707106781186548);
+  }
+
+  /* perform 4 times fft16 */
+  for (block = 0; block < 128; block += 32) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W4 */
+                  Y[block + 2 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  (double) +0.923879532511287, (double) -0.382683432365090);
+    BUTTERFLY_yY (Y[block + 4],               /* W8 */
+                  Y[block + 4 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  (double) +0.707106781186548, (double) -0.707106781186547);
+    BUTTERFLY_XY (Y[block + 6],               /* W12 */
+                  Y[block + 6 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  (double) +0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_0m (Y[block + 8],               /* W16 */
+                  Y[block + 8 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+    BUTTERFLY_XY (Y[block + 10],               /* W20 */
+                  Y[block + 10 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  (double) -0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_XX (Y[block + 12],               /* W24 */
+                  Y[block + 12 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  (double) -0.707106781186547, (double) -0.707106781186548);
+    BUTTERFLY_XY (Y[block + 14],               /* W28 */
+                  Y[block + 14 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  (double) -0.923879532511287, (double) -0.382683432365090);
+  }
+
+  /* perform 2 times fft32 */
+  for (block = 0; block < 128; block += 64) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W2 */
+                  Y[block + 2 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  (double) +0.980785280403230, (double) -0.195090322016128);
+    BUTTERFLY_XY (Y[block + 4],               /* W4 */
+                  Y[block + 4 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  (double) +0.923879532511287, (double) -0.382683432365090);
+    BUTTERFLY_XY (Y[block + 6],               /* W6 */
+                  Y[block + 6 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  (double) +0.831469612302545, (double) -0.555570233019602);
+    BUTTERFLY_yY (Y[block + 8],               /* W8 */
+                  Y[block + 8 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  (double) +0.707106781186548, (double) -0.707106781186547);
+    BUTTERFLY_XY (Y[block + 10],               /* W10 */
+                  Y[block + 10 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  (double) +0.555570233019602, (double) -0.831469612302545);
+    BUTTERFLY_XY (Y[block + 12],               /* W12 */
+                  Y[block + 12 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  (double) +0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_XY (Y[block + 14],               /* W14 */
+                  Y[block + 14 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  (double) +0.195090322016128, (double) -0.980785280403230);
+    BUTTERFLY_0m (Y[block + 16],               /* W16 */
+                  Y[block + 16 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+    BUTTERFLY_XY (Y[block + 18],               /* W18 */
+                  Y[block + 18 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  (double) -0.195090322016128, (double) -0.980785280403230);
+    BUTTERFLY_XY (Y[block + 20],               /* W20 */
+                  Y[block + 20 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  (double) -0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_XY (Y[block + 22],               /* W22 */
+                  Y[block + 22 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  (double) -0.555570233019602, (double) -0.831469612302545);
+    BUTTERFLY_XX (Y[block + 24],               /* W24 */
+                  Y[block + 24 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  (double) -0.707106781186547, (double) -0.707106781186548);
+    BUTTERFLY_XY (Y[block + 26],               /* W26 */
+                  Y[block + 26 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  (double) -0.831469612302545, (double) -0.555570233019602);
+    BUTTERFLY_XY (Y[block + 28],               /* W28 */
+                  Y[block + 28 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  (double) -0.923879532511287, (double) -0.382683432365090);
+    BUTTERFLY_XY (Y[block + 30],               /* W30 */
+                  Y[block + 30 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  (double) -0.980785280403230, (double) -0.195090322016129);
+  }
+
+  /* perform 1 times fft64 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[64],
+                Y[64 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[64],
+                Y[64 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[66],
+                Y[66 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[66],
+                Y[66 + 1],
+                (double) +0.995184726672197, (double) -0.098017140329561);
+  BUTTERFLY_XY (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[68],
+                Y[68 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[68],
+                Y[68 + 1],
+                (double) +0.980785280403230, (double) -0.195090322016128);
+  BUTTERFLY_XY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[70],
+                Y[70 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[70],
+                Y[70 + 1],
+                (double) +0.956940335732209, (double) -0.290284677254462);
+  BUTTERFLY_XY (Y[8],               /* W4 */
+                Y[8 + 1],
+                Y[72],
+                Y[72 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[72],
+                Y[72 + 1],
+                (double) +0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_XY (Y[10],               /* W5 */
+                Y[10 + 1],
+                Y[74],
+                Y[74 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[74],
+                Y[74 + 1],
+                (double) +0.881921264348355, (double) -0.471396736825998);
+  BUTTERFLY_XY (Y[12],               /* W6 */
+                Y[12 + 1],
+                Y[76],
+                Y[76 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[76],
+                Y[76 + 1],
+                (double) +0.831469612302545, (double) -0.555570233019602);
+  BUTTERFLY_XY (Y[14],               /* W7 */
+                Y[14 + 1],
+                Y[78],
+                Y[78 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[78],
+                Y[78 + 1],
+                (double) +0.773010453362737, (double) -0.634393284163645);
+  BUTTERFLY_yY (Y[16],               /* W8 */
+                Y[16 + 1],
+                Y[80],
+                Y[80 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[80],
+                Y[80 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_XY (Y[18],               /* W9 */
+                Y[18 + 1],
+                Y[82],
+                Y[82 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[82],
+                Y[82 + 1],
+                (double) +0.634393284163645, (double) -0.773010453362737);
+  BUTTERFLY_XY (Y[20],               /* W10 */
+                Y[20 + 1],
+                Y[84],
+                Y[84 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[84],
+                Y[84 + 1],
+                (double) +0.555570233019602, (double) -0.831469612302545);
+  BUTTERFLY_XY (Y[22],               /* W11 */
+                Y[22 + 1],
+                Y[86],
+                Y[86 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[86],
+                Y[86 + 1],
+                (double) +0.471396736825998, (double) -0.881921264348355);
+  BUTTERFLY_XY (Y[24],               /* W12 */
+                Y[24 + 1],
+                Y[88],
+                Y[88 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[88],
+                Y[88 + 1],
+                (double) +0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XY (Y[26],               /* W13 */
+                Y[26 + 1],
+                Y[90],
+                Y[90 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[90],
+                Y[90 + 1],
+                (double) +0.290284677254462, (double) -0.956940335732209);
+  BUTTERFLY_XY (Y[28],               /* W14 */
+                Y[28 + 1],
+                Y[92],
+                Y[92 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[92],
+                Y[92 + 1],
+                (double) +0.195090322016128, (double) -0.980785280403230);
+  BUTTERFLY_XY (Y[30],               /* W15 */
+                Y[30 + 1],
+                Y[94],
+                Y[94 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[94],
+                Y[94 + 1],
+                (double) +0.098017140329561, (double) -0.995184726672197);
+  BUTTERFLY_0m (Y[32],               /* W16 */
+                Y[32 + 1],
+                Y[96],
+                Y[96 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[96],
+                Y[96 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_XY (Y[34],               /* W17 */
+                Y[34 + 1],
+                Y[98],
+                Y[98 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[98],
+                Y[98 + 1],
+                (double) -0.098017140329561, (double) -0.995184726672197);
+  BUTTERFLY_XY (Y[36],               /* W18 */
+                Y[36 + 1],
+                Y[100],
+                Y[100 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[100],
+                Y[100 + 1],
+                (double) -0.195090322016128, (double) -0.980785280403230);
+  BUTTERFLY_XY (Y[38],               /* W19 */
+                Y[38 + 1],
+                Y[102],
+                Y[102 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[102],
+                Y[102 + 1],
+                (double) -0.290284677254462, (double) -0.956940335732209);
+  BUTTERFLY_XY (Y[40],               /* W20 */
+                Y[40 + 1],
+                Y[104],
+                Y[104 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[104],
+                Y[104 + 1],
+                (double) -0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XY (Y[42],               /* W21 */
+                Y[42 + 1],
+                Y[106],
+                Y[106 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[106],
+                Y[106 + 1],
+                (double) -0.471396736825998, (double) -0.881921264348355);
+  BUTTERFLY_XY (Y[44],               /* W22 */
+                Y[44 + 1],
+                Y[108],
+                Y[108 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[108],
+                Y[108 + 1],
+                (double) -0.555570233019602, (double) -0.831469612302545);
+  BUTTERFLY_XY (Y[46],               /* W23 */
+                Y[46 + 1],
+                Y[110],
+                Y[110 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[110],
+                Y[110 + 1],
+                (double) -0.634393284163645, (double) -0.773010453362737);
+  BUTTERFLY_XX (Y[48],               /* W24 */
+                Y[48 + 1],
+                Y[112],
+                Y[112 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[112],
+                Y[112 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XY (Y[50],               /* W25 */
+                Y[50 + 1],
+                Y[114],
+                Y[114 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[114],
+                Y[114 + 1],
+                (double) -0.773010453362737, (double) -0.634393284163645);
+  BUTTERFLY_XY (Y[52],               /* W26 */
+                Y[52 + 1],
+                Y[116],
+                Y[116 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[116],
+                Y[116 + 1],
+                (double) -0.831469612302545, (double) -0.555570233019602);
+  BUTTERFLY_XY (Y[54],               /* W27 */
+                Y[54 + 1],
+                Y[118],
+                Y[118 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[118],
+                Y[118 + 1],
+                (double) -0.881921264348355, (double) -0.471396736825998);
+  BUTTERFLY_XY (Y[56],               /* W28 */
+                Y[56 + 1],
+                Y[120],
+                Y[120 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[120],
+                Y[120 + 1],
+                (double) -0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_XY (Y[58],               /* W29 */
+                Y[58 + 1],
+                Y[122],
+                Y[122 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[122],
+                Y[122 + 1],
+                (double) -0.956940335732209, (double) -0.290284677254462);
+  BUTTERFLY_XY (Y[60],               /* W30 */
+                Y[60 + 1],
+                Y[124],
+                Y[124 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[124],
+                Y[124 + 1],
+                (double) -0.980785280403230, (double) -0.195090322016129);
+  BUTTERFLY_XY (Y[62],               /* W31 */
+                Y[62 + 1],
+                Y[126],
+                Y[126 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[126],
+                Y[126 + 1],
+                (double) -0.995184726672197, (double) -0.098017140329561);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 64 F S S S S X)
+ **/
+static void
+gsl_power2_fft64synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform 32 times fft2 */
+  BUTTERFLY_10scale (X[0], X[0 + 1],
+                  X[64], X[64 + 1],
+                  Y[0], Y[0 + 1],
+                  Y[2], Y[2 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[32], X[32 + 1],
+                  X[96], X[96 + 1],
+                  Y[4], Y[4 + 1],
+                  Y[6], Y[6 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[16], X[16 + 1],
+                  X[80], X[80 + 1],
+                  Y[8], Y[8 + 1],
+                  Y[10], Y[10 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[48], X[48 + 1],
+                  X[112], X[112 + 1],
+                  Y[12], Y[12 + 1],
+                  Y[14], Y[14 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[8], X[8 + 1],
+                  X[72], X[72 + 1],
+                  Y[16], Y[16 + 1],
+                  Y[18], Y[18 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[40], X[40 + 1],
+                  X[104], X[104 + 1],
+                  Y[20], Y[20 + 1],
+                  Y[22], Y[22 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[24], X[24 + 1],
+                  X[88], X[88 + 1],
+                  Y[24], Y[24 + 1],
+                  Y[26], Y[26 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[56], X[56 + 1],
+                  X[120], X[120 + 1],
+                  Y[28], Y[28 + 1],
+                  Y[30], Y[30 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[4], X[4 + 1],
+                  X[68], X[68 + 1],
+                  Y[32], Y[32 + 1],
+                  Y[34], Y[34 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[36], X[36 + 1],
+                  X[100], X[100 + 1],
+                  Y[36], Y[36 + 1],
+                  Y[38], Y[38 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[20], X[20 + 1],
+                  X[84], X[84 + 1],
+                  Y[40], Y[40 + 1],
+                  Y[42], Y[42 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[52], X[52 + 1],
+                  X[116], X[116 + 1],
+                  Y[44], Y[44 + 1],
+                  Y[46], Y[46 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[12], X[12 + 1],
+                  X[76], X[76 + 1],
+                  Y[48], Y[48 + 1],
+                  Y[50], Y[50 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[44], X[44 + 1],
+                  X[108], X[108 + 1],
+                  Y[52], Y[52 + 1],
+                  Y[54], Y[54 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[28], X[28 + 1],
+                  X[92], X[92 + 1],
+                  Y[56], Y[56 + 1],
+                  Y[58], Y[58 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[60], X[60 + 1],
+                  X[124], X[124 + 1],
+                  Y[60], Y[60 + 1],
+                  Y[62], Y[62 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[2], X[2 + 1],
+                  X[66], X[66 + 1],
+                  Y[64], Y[64 + 1],
+                  Y[66], Y[66 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[34], X[34 + 1],
+                  X[98], X[98 + 1],
+                  Y[68], Y[68 + 1],
+                  Y[70], Y[70 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[18], X[18 + 1],
+                  X[82], X[82 + 1],
+                  Y[72], Y[72 + 1],
+                  Y[74], Y[74 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[50], X[50 + 1],
+                  X[114], X[114 + 1],
+                  Y[76], Y[76 + 1],
+                  Y[78], Y[78 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[10], X[10 + 1],
+                  X[74], X[74 + 1],
+                  Y[80], Y[80 + 1],
+                  Y[82], Y[82 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[42], X[42 + 1],
+                  X[106], X[106 + 1],
+                  Y[84], Y[84 + 1],
+                  Y[86], Y[86 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[26], X[26 + 1],
+                  X[90], X[90 + 1],
+                  Y[88], Y[88 + 1],
+                  Y[90], Y[90 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[58], X[58 + 1],
+                  X[122], X[122 + 1],
+                  Y[92], Y[92 + 1],
+                  Y[94], Y[94 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[6], X[6 + 1],
+                  X[70], X[70 + 1],
+                  Y[96], Y[96 + 1],
+                  Y[98], Y[98 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[38], X[38 + 1],
+                  X[102], X[102 + 1],
+                  Y[100], Y[100 + 1],
+                  Y[102], Y[102 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[22], X[22 + 1],
+                  X[86], X[86 + 1],
+                  Y[104], Y[104 + 1],
+                  Y[106], Y[106 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[54], X[54 + 1],
+                  X[118], X[118 + 1],
+                  Y[108], Y[108 + 1],
+                  Y[110], Y[110 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[14], X[14 + 1],
+                  X[78], X[78 + 1],
+                  Y[112], Y[112 + 1],
+                  Y[114], Y[114 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[46], X[46 + 1],
+                  X[110], X[110 + 1],
+                  Y[116], Y[116 + 1],
+                  Y[118], Y[118 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[30], X[30 + 1],
+                  X[94], X[94 + 1],
+                  Y[120], Y[120 + 1],
+                  Y[122], Y[122 + 1],
+                  1.0 / (double) 64);
+  BUTTERFLY_10scale (X[62], X[62 + 1],
+                  X[126], X[126 + 1],
+                  Y[124], Y[124 + 1],
+                  Y[126], Y[126 + 1],
+                  1.0 / (double) 64);
+
+  /* skipping 16 times fft4 */
+
+  /* skipping 8 times fft8 */
+
+  /* skipping 4 times fft16 */
+
+  /* skipping 2 times fft32 */
+
+  /* perform 1 times fft64 */
+  gsl_power2_fft64synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 128 S R R R R R F)
+ **/
+static void
+gsl_power2_fft128synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 64 times fft2 */
+
+  /* perform 32 times fft4 */
+  for (block = 0; block < 256; block += 8) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_0m (Y[block + 2],               /* W32 */
+                  Y[block + 2 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+  }
+
+  /* perform 16 times fft8 */
+  for (block = 0; block < 256; block += 16) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_yY (Y[block + 2],               /* W16 */
+                  Y[block + 2 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  (double) +0.707106781186548, (double) -0.707106781186547);
+    BUTTERFLY_0m (Y[block + 4],               /* W32 */
+                  Y[block + 4 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+    BUTTERFLY_XX (Y[block + 6],               /* W48 */
+                  Y[block + 6 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  (double) -0.707106781186547, (double) -0.707106781186548);
+  }
+
+  /* perform 8 times fft16 */
+  for (block = 0; block < 256; block += 32) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W8 */
+                  Y[block + 2 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  (double) +0.923879532511287, (double) -0.382683432365090);
+    BUTTERFLY_yY (Y[block + 4],               /* W16 */
+                  Y[block + 4 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  (double) +0.707106781186548, (double) -0.707106781186547);
+    BUTTERFLY_XY (Y[block + 6],               /* W24 */
+                  Y[block + 6 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  (double) +0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_0m (Y[block + 8],               /* W32 */
+                  Y[block + 8 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+    BUTTERFLY_XY (Y[block + 10],               /* W40 */
+                  Y[block + 10 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  (double) -0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_XX (Y[block + 12],               /* W48 */
+                  Y[block + 12 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  (double) -0.707106781186547, (double) -0.707106781186548);
+    BUTTERFLY_XY (Y[block + 14],               /* W56 */
+                  Y[block + 14 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  (double) -0.923879532511287, (double) -0.382683432365090);
+  }
+
+  /* perform 4 times fft32 */
+  for (block = 0; block < 256; block += 64) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W4 */
+                  Y[block + 2 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  (double) +0.980785280403230, (double) -0.195090322016128);
+    BUTTERFLY_XY (Y[block + 4],               /* W8 */
+                  Y[block + 4 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  (double) +0.923879532511287, (double) -0.382683432365090);
+    BUTTERFLY_XY (Y[block + 6],               /* W12 */
+                  Y[block + 6 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  (double) +0.831469612302545, (double) -0.555570233019602);
+    BUTTERFLY_yY (Y[block + 8],               /* W16 */
+                  Y[block + 8 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  (double) +0.707106781186548, (double) -0.707106781186547);
+    BUTTERFLY_XY (Y[block + 10],               /* W20 */
+                  Y[block + 10 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  (double) +0.555570233019602, (double) -0.831469612302545);
+    BUTTERFLY_XY (Y[block + 12],               /* W24 */
+                  Y[block + 12 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  (double) +0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_XY (Y[block + 14],               /* W28 */
+                  Y[block + 14 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  (double) +0.195090322016128, (double) -0.980785280403230);
+    BUTTERFLY_0m (Y[block + 16],               /* W32 */
+                  Y[block + 16 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+    BUTTERFLY_XY (Y[block + 18],               /* W36 */
+                  Y[block + 18 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  (double) -0.195090322016128, (double) -0.980785280403230);
+    BUTTERFLY_XY (Y[block + 20],               /* W40 */
+                  Y[block + 20 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  (double) -0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_XY (Y[block + 22],               /* W44 */
+                  Y[block + 22 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  (double) -0.555570233019602, (double) -0.831469612302545);
+    BUTTERFLY_XX (Y[block + 24],               /* W48 */
+                  Y[block + 24 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  (double) -0.707106781186547, (double) -0.707106781186548);
+    BUTTERFLY_XY (Y[block + 26],               /* W52 */
+                  Y[block + 26 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  (double) -0.831469612302545, (double) -0.555570233019602);
+    BUTTERFLY_XY (Y[block + 28],               /* W56 */
+                  Y[block + 28 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  (double) -0.923879532511287, (double) -0.382683432365090);
+    BUTTERFLY_XY (Y[block + 30],               /* W60 */
+                  Y[block + 30 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  (double) -0.980785280403230, (double) -0.195090322016129);
+  }
+
+  /* perform 2 times fft64 */
+  for (block = 0; block < 256; block += 128) {
+    BUTTERFLY_10 (Y[block + 0],               /* W0 */
+                  Y[block + 0 + 1],
+                  Y[block + 64],
+                  Y[block + 64 + 1],
+                  Y[block + 0],
+                  Y[block + 0 + 1],
+                  Y[block + 64],
+                  Y[block + 64 + 1],
+                  (double) +1.000000000000000, (double) +0.000000000000000);
+    BUTTERFLY_XY (Y[block + 2],               /* W2 */
+                  Y[block + 2 + 1],
+                  Y[block + 66],
+                  Y[block + 66 + 1],
+                  Y[block + 2],
+                  Y[block + 2 + 1],
+                  Y[block + 66],
+                  Y[block + 66 + 1],
+                  (double) +0.995184726672197, (double) -0.098017140329561);
+    BUTTERFLY_XY (Y[block + 4],               /* W4 */
+                  Y[block + 4 + 1],
+                  Y[block + 68],
+                  Y[block + 68 + 1],
+                  Y[block + 4],
+                  Y[block + 4 + 1],
+                  Y[block + 68],
+                  Y[block + 68 + 1],
+                  (double) +0.980785280403230, (double) -0.195090322016128);
+    BUTTERFLY_XY (Y[block + 6],               /* W6 */
+                  Y[block + 6 + 1],
+                  Y[block + 70],
+                  Y[block + 70 + 1],
+                  Y[block + 6],
+                  Y[block + 6 + 1],
+                  Y[block + 70],
+                  Y[block + 70 + 1],
+                  (double) +0.956940335732209, (double) -0.290284677254462);
+    BUTTERFLY_XY (Y[block + 8],               /* W8 */
+                  Y[block + 8 + 1],
+                  Y[block + 72],
+                  Y[block + 72 + 1],
+                  Y[block + 8],
+                  Y[block + 8 + 1],
+                  Y[block + 72],
+                  Y[block + 72 + 1],
+                  (double) +0.923879532511287, (double) -0.382683432365090);
+    BUTTERFLY_XY (Y[block + 10],               /* W10 */
+                  Y[block + 10 + 1],
+                  Y[block + 74],
+                  Y[block + 74 + 1],
+                  Y[block + 10],
+                  Y[block + 10 + 1],
+                  Y[block + 74],
+                  Y[block + 74 + 1],
+                  (double) +0.881921264348355, (double) -0.471396736825998);
+    BUTTERFLY_XY (Y[block + 12],               /* W12 */
+                  Y[block + 12 + 1],
+                  Y[block + 76],
+                  Y[block + 76 + 1],
+                  Y[block + 12],
+                  Y[block + 12 + 1],
+                  Y[block + 76],
+                  Y[block + 76 + 1],
+                  (double) +0.831469612302545, (double) -0.555570233019602);
+    BUTTERFLY_XY (Y[block + 14],               /* W14 */
+                  Y[block + 14 + 1],
+                  Y[block + 78],
+                  Y[block + 78 + 1],
+                  Y[block + 14],
+                  Y[block + 14 + 1],
+                  Y[block + 78],
+                  Y[block + 78 + 1],
+                  (double) +0.773010453362737, (double) -0.634393284163645);
+    BUTTERFLY_yY (Y[block + 16],               /* W16 */
+                  Y[block + 16 + 1],
+                  Y[block + 80],
+                  Y[block + 80 + 1],
+                  Y[block + 16],
+                  Y[block + 16 + 1],
+                  Y[block + 80],
+                  Y[block + 80 + 1],
+                  (double) +0.707106781186548, (double) -0.707106781186547);
+    BUTTERFLY_XY (Y[block + 18],               /* W18 */
+                  Y[block + 18 + 1],
+                  Y[block + 82],
+                  Y[block + 82 + 1],
+                  Y[block + 18],
+                  Y[block + 18 + 1],
+                  Y[block + 82],
+                  Y[block + 82 + 1],
+                  (double) +0.634393284163645, (double) -0.773010453362737);
+    BUTTERFLY_XY (Y[block + 20],               /* W20 */
+                  Y[block + 20 + 1],
+                  Y[block + 84],
+                  Y[block + 84 + 1],
+                  Y[block + 20],
+                  Y[block + 20 + 1],
+                  Y[block + 84],
+                  Y[block + 84 + 1],
+                  (double) +0.555570233019602, (double) -0.831469612302545);
+    BUTTERFLY_XY (Y[block + 22],               /* W22 */
+                  Y[block + 22 + 1],
+                  Y[block + 86],
+                  Y[block + 86 + 1],
+                  Y[block + 22],
+                  Y[block + 22 + 1],
+                  Y[block + 86],
+                  Y[block + 86 + 1],
+                  (double) +0.471396736825998, (double) -0.881921264348355);
+    BUTTERFLY_XY (Y[block + 24],               /* W24 */
+                  Y[block + 24 + 1],
+                  Y[block + 88],
+                  Y[block + 88 + 1],
+                  Y[block + 24],
+                  Y[block + 24 + 1],
+                  Y[block + 88],
+                  Y[block + 88 + 1],
+                  (double) +0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_XY (Y[block + 26],               /* W26 */
+                  Y[block + 26 + 1],
+                  Y[block + 90],
+                  Y[block + 90 + 1],
+                  Y[block + 26],
+                  Y[block + 26 + 1],
+                  Y[block + 90],
+                  Y[block + 90 + 1],
+                  (double) +0.290284677254462, (double) -0.956940335732209);
+    BUTTERFLY_XY (Y[block + 28],               /* W28 */
+                  Y[block + 28 + 1],
+                  Y[block + 92],
+                  Y[block + 92 + 1],
+                  Y[block + 28],
+                  Y[block + 28 + 1],
+                  Y[block + 92],
+                  Y[block + 92 + 1],
+                  (double) +0.195090322016128, (double) -0.980785280403230);
+    BUTTERFLY_XY (Y[block + 30],               /* W30 */
+                  Y[block + 30 + 1],
+                  Y[block + 94],
+                  Y[block + 94 + 1],
+                  Y[block + 30],
+                  Y[block + 30 + 1],
+                  Y[block + 94],
+                  Y[block + 94 + 1],
+                  (double) +0.098017140329561, (double) -0.995184726672197);
+    BUTTERFLY_0m (Y[block + 32],               /* W32 */
+                  Y[block + 32 + 1],
+                  Y[block + 96],
+                  Y[block + 96 + 1],
+                  Y[block + 32],
+                  Y[block + 32 + 1],
+                  Y[block + 96],
+                  Y[block + 96 + 1],
+                  (double) +0.000000000000000, (double) -1.000000000000000);
+    BUTTERFLY_XY (Y[block + 34],               /* W34 */
+                  Y[block + 34 + 1],
+                  Y[block + 98],
+                  Y[block + 98 + 1],
+                  Y[block + 34],
+                  Y[block + 34 + 1],
+                  Y[block + 98],
+                  Y[block + 98 + 1],
+                  (double) -0.098017140329561, (double) -0.995184726672197);
+    BUTTERFLY_XY (Y[block + 36],               /* W36 */
+                  Y[block + 36 + 1],
+                  Y[block + 100],
+                  Y[block + 100 + 1],
+                  Y[block + 36],
+                  Y[block + 36 + 1],
+                  Y[block + 100],
+                  Y[block + 100 + 1],
+                  (double) -0.195090322016128, (double) -0.980785280403230);
+    BUTTERFLY_XY (Y[block + 38],               /* W38 */
+                  Y[block + 38 + 1],
+                  Y[block + 102],
+                  Y[block + 102 + 1],
+                  Y[block + 38],
+                  Y[block + 38 + 1],
+                  Y[block + 102],
+                  Y[block + 102 + 1],
+                  (double) -0.290284677254462, (double) -0.956940335732209);
+    BUTTERFLY_XY (Y[block + 40],               /* W40 */
+                  Y[block + 40 + 1],
+                  Y[block + 104],
+                  Y[block + 104 + 1],
+                  Y[block + 40],
+                  Y[block + 40 + 1],
+                  Y[block + 104],
+                  Y[block + 104 + 1],
+                  (double) -0.382683432365090, (double) -0.923879532511287);
+    BUTTERFLY_XY (Y[block + 42],               /* W42 */
+                  Y[block + 42 + 1],
+                  Y[block + 106],
+                  Y[block + 106 + 1],
+                  Y[block + 42],
+                  Y[block + 42 + 1],
+                  Y[block + 106],
+                  Y[block + 106 + 1],
+                  (double) -0.471396736825998, (double) -0.881921264348355);
+    BUTTERFLY_XY (Y[block + 44],               /* W44 */
+                  Y[block + 44 + 1],
+                  Y[block + 108],
+                  Y[block + 108 + 1],
+                  Y[block + 44],
+                  Y[block + 44 + 1],
+                  Y[block + 108],
+                  Y[block + 108 + 1],
+                  (double) -0.555570233019602, (double) -0.831469612302545);
+    BUTTERFLY_XY (Y[block + 46],               /* W46 */
+                  Y[block + 46 + 1],
+                  Y[block + 110],
+                  Y[block + 110 + 1],
+                  Y[block + 46],
+                  Y[block + 46 + 1],
+                  Y[block + 110],
+                  Y[block + 110 + 1],
+                  (double) -0.634393284163645, (double) -0.773010453362737);
+    BUTTERFLY_XX (Y[block + 48],               /* W48 */
+                  Y[block + 48 + 1],
+                  Y[block + 112],
+                  Y[block + 112 + 1],
+                  Y[block + 48],
+                  Y[block + 48 + 1],
+                  Y[block + 112],
+                  Y[block + 112 + 1],
+                  (double) -0.707106781186547, (double) -0.707106781186548);
+    BUTTERFLY_XY (Y[block + 50],               /* W50 */
+                  Y[block + 50 + 1],
+                  Y[block + 114],
+                  Y[block + 114 + 1],
+                  Y[block + 50],
+                  Y[block + 50 + 1],
+                  Y[block + 114],
+                  Y[block + 114 + 1],
+                  (double) -0.773010453362737, (double) -0.634393284163645);
+    BUTTERFLY_XY (Y[block + 52],               /* W52 */
+                  Y[block + 52 + 1],
+                  Y[block + 116],
+                  Y[block + 116 + 1],
+                  Y[block + 52],
+                  Y[block + 52 + 1],
+                  Y[block + 116],
+                  Y[block + 116 + 1],
+                  (double) -0.831469612302545, (double) -0.555570233019602);
+    BUTTERFLY_XY (Y[block + 54],               /* W54 */
+                  Y[block + 54 + 1],
+                  Y[block + 118],
+                  Y[block + 118 + 1],
+                  Y[block + 54],
+                  Y[block + 54 + 1],
+                  Y[block + 118],
+                  Y[block + 118 + 1],
+                  (double) -0.881921264348355, (double) -0.471396736825998);
+    BUTTERFLY_XY (Y[block + 56],               /* W56 */
+                  Y[block + 56 + 1],
+                  Y[block + 120],
+                  Y[block + 120 + 1],
+                  Y[block + 56],
+                  Y[block + 56 + 1],
+                  Y[block + 120],
+                  Y[block + 120 + 1],
+                  (double) -0.923879532511287, (double) -0.382683432365090);
+    BUTTERFLY_XY (Y[block + 58],               /* W58 */
+                  Y[block + 58 + 1],
+                  Y[block + 122],
+                  Y[block + 122 + 1],
+                  Y[block + 58],
+                  Y[block + 58 + 1],
+                  Y[block + 122],
+                  Y[block + 122 + 1],
+                  (double) -0.956940335732209, (double) -0.290284677254462);
+    BUTTERFLY_XY (Y[block + 60],               /* W60 */
+                  Y[block + 60 + 1],
+                  Y[block + 124],
+                  Y[block + 124 + 1],
+                  Y[block + 60],
+                  Y[block + 60 + 1],
+                  Y[block + 124],
+                  Y[block + 124 + 1],
+                  (double) -0.980785280403230, (double) -0.195090322016129);
+    BUTTERFLY_XY (Y[block + 62],               /* W62 */
+                  Y[block + 62 + 1],
+                  Y[block + 126],
+                  Y[block + 126 + 1],
+                  Y[block + 62],
+                  Y[block + 62 + 1],
+                  Y[block + 126],
+                  Y[block + 126 + 1],
+                  (double) -0.995184726672197, (double) -0.098017140329561);
+  }
+
+  /* perform 1 times fft128 */
+  BUTTERFLY_10 (Y[0],               /* W0 */
+                Y[0 + 1],
+                Y[128],
+                Y[128 + 1],
+                Y[0],
+                Y[0 + 1],
+                Y[128],
+                Y[128 + 1],
+                (double) +1.000000000000000, (double) +0.000000000000000);
+  BUTTERFLY_XY (Y[2],               /* W1 */
+                Y[2 + 1],
+                Y[130],
+                Y[130 + 1],
+                Y[2],
+                Y[2 + 1],
+                Y[130],
+                Y[130 + 1],
+                (double) +0.998795456205172, (double) -0.049067674327418);
+  BUTTERFLY_XY (Y[4],               /* W2 */
+                Y[4 + 1],
+                Y[132],
+                Y[132 + 1],
+                Y[4],
+                Y[4 + 1],
+                Y[132],
+                Y[132 + 1],
+                (double) +0.995184726672197, (double) -0.098017140329561);
+  BUTTERFLY_XY (Y[6],               /* W3 */
+                Y[6 + 1],
+                Y[134],
+                Y[134 + 1],
+                Y[6],
+                Y[6 + 1],
+                Y[134],
+                Y[134 + 1],
+                (double) +0.989176509964781, (double) -0.146730474455362);
+  BUTTERFLY_XY (Y[8],               /* W4 */
+                Y[8 + 1],
+                Y[136],
+                Y[136 + 1],
+                Y[8],
+                Y[8 + 1],
+                Y[136],
+                Y[136 + 1],
+                (double) +0.980785280403230, (double) -0.195090322016128);
+  BUTTERFLY_XY (Y[10],               /* W5 */
+                Y[10 + 1],
+                Y[138],
+                Y[138 + 1],
+                Y[10],
+                Y[10 + 1],
+                Y[138],
+                Y[138 + 1],
+                (double) +0.970031253194544, (double) -0.242980179903264);
+  BUTTERFLY_XY (Y[12],               /* W6 */
+                Y[12 + 1],
+                Y[140],
+                Y[140 + 1],
+                Y[12],
+                Y[12 + 1],
+                Y[140],
+                Y[140 + 1],
+                (double) +0.956940335732209, (double) -0.290284677254462);
+  BUTTERFLY_XY (Y[14],               /* W7 */
+                Y[14 + 1],
+                Y[142],
+                Y[142 + 1],
+                Y[14],
+                Y[14 + 1],
+                Y[142],
+                Y[142 + 1],
+                (double) +0.941544065183021, (double) -0.336889853392220);
+  BUTTERFLY_XY (Y[16],               /* W8 */
+                Y[16 + 1],
+                Y[144],
+                Y[144 + 1],
+                Y[16],
+                Y[16 + 1],
+                Y[144],
+                Y[144 + 1],
+                (double) +0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_XY (Y[18],               /* W9 */
+                Y[18 + 1],
+                Y[146],
+                Y[146 + 1],
+                Y[18],
+                Y[18 + 1],
+                Y[146],
+                Y[146 + 1],
+                (double) +0.903989293123443, (double) -0.427555093430282);
+  BUTTERFLY_XY (Y[20],               /* W10 */
+                Y[20 + 1],
+                Y[148],
+                Y[148 + 1],
+                Y[20],
+                Y[20 + 1],
+                Y[148],
+                Y[148 + 1],
+                (double) +0.881921264348355, (double) -0.471396736825998);
+  BUTTERFLY_XY (Y[22],               /* W11 */
+                Y[22 + 1],
+                Y[150],
+                Y[150 + 1],
+                Y[22],
+                Y[22 + 1],
+                Y[150],
+                Y[150 + 1],
+                (double) +0.857728610000272, (double) -0.514102744193222);
+  BUTTERFLY_XY (Y[24],               /* W12 */
+                Y[24 + 1],
+                Y[152],
+                Y[152 + 1],
+                Y[24],
+                Y[24 + 1],
+                Y[152],
+                Y[152 + 1],
+                (double) +0.831469612302545, (double) -0.555570233019602);
+  BUTTERFLY_XY (Y[26],               /* W13 */
+                Y[26 + 1],
+                Y[154],
+                Y[154 + 1],
+                Y[26],
+                Y[26 + 1],
+                Y[154],
+                Y[154 + 1],
+                (double) +0.803207531480645, (double) -0.595699304492433);
+  BUTTERFLY_XY (Y[28],               /* W14 */
+                Y[28 + 1],
+                Y[156],
+                Y[156 + 1],
+                Y[28],
+                Y[28 + 1],
+                Y[156],
+                Y[156 + 1],
+                (double) +0.773010453362737, (double) -0.634393284163645);
+  BUTTERFLY_XY (Y[30],               /* W15 */
+                Y[30 + 1],
+                Y[158],
+                Y[158 + 1],
+                Y[30],
+                Y[30 + 1],
+                Y[158],
+                Y[158 + 1],
+                (double) +0.740951125354959, (double) -0.671558954847018);
+  BUTTERFLY_yY (Y[32],               /* W16 */
+                Y[32 + 1],
+                Y[160],
+                Y[160 + 1],
+                Y[32],
+                Y[32 + 1],
+                Y[160],
+                Y[160 + 1],
+                (double) +0.707106781186548, (double) -0.707106781186547);
+  BUTTERFLY_XY (Y[34],               /* W17 */
+                Y[34 + 1],
+                Y[162],
+                Y[162 + 1],
+                Y[34],
+                Y[34 + 1],
+                Y[162],
+                Y[162 + 1],
+                (double) +0.671558954847018, (double) -0.740951125354959);
+  BUTTERFLY_XY (Y[36],               /* W18 */
+                Y[36 + 1],
+                Y[164],
+                Y[164 + 1],
+                Y[36],
+                Y[36 + 1],
+                Y[164],
+                Y[164 + 1],
+                (double) +0.634393284163645, (double) -0.773010453362737);
+  BUTTERFLY_XY (Y[38],               /* W19 */
+                Y[38 + 1],
+                Y[166],
+                Y[166 + 1],
+                Y[38],
+                Y[38 + 1],
+                Y[166],
+                Y[166 + 1],
+                (double) +0.595699304492433, (double) -0.803207531480645);
+  BUTTERFLY_XY (Y[40],               /* W20 */
+                Y[40 + 1],
+                Y[168],
+                Y[168 + 1],
+                Y[40],
+                Y[40 + 1],
+                Y[168],
+                Y[168 + 1],
+                (double) +0.555570233019602, (double) -0.831469612302545);
+  BUTTERFLY_XY (Y[42],               /* W21 */
+                Y[42 + 1],
+                Y[170],
+                Y[170 + 1],
+                Y[42],
+                Y[42 + 1],
+                Y[170],
+                Y[170 + 1],
+                (double) +0.514102744193222, (double) -0.857728610000272);
+  BUTTERFLY_XY (Y[44],               /* W22 */
+                Y[44 + 1],
+                Y[172],
+                Y[172 + 1],
+                Y[44],
+                Y[44 + 1],
+                Y[172],
+                Y[172 + 1],
+                (double) +0.471396736825998, (double) -0.881921264348355);
+  BUTTERFLY_XY (Y[46],               /* W23 */
+                Y[46 + 1],
+                Y[174],
+                Y[174 + 1],
+                Y[46],
+                Y[46 + 1],
+                Y[174],
+                Y[174 + 1],
+                (double) +0.427555093430282, (double) -0.903989293123443);
+  BUTTERFLY_XY (Y[48],               /* W24 */
+                Y[48 + 1],
+                Y[176],
+                Y[176 + 1],
+                Y[48],
+                Y[48 + 1],
+                Y[176],
+                Y[176 + 1],
+                (double) +0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XY (Y[50],               /* W25 */
+                Y[50 + 1],
+                Y[178],
+                Y[178 + 1],
+                Y[50],
+                Y[50 + 1],
+                Y[178],
+                Y[178 + 1],
+                (double) +0.336889853392220, (double) -0.941544065183021);
+  BUTTERFLY_XY (Y[52],               /* W26 */
+                Y[52 + 1],
+                Y[180],
+                Y[180 + 1],
+                Y[52],
+                Y[52 + 1],
+                Y[180],
+                Y[180 + 1],
+                (double) +0.290284677254462, (double) -0.956940335732209);
+  BUTTERFLY_XY (Y[54],               /* W27 */
+                Y[54 + 1],
+                Y[182],
+                Y[182 + 1],
+                Y[54],
+                Y[54 + 1],
+                Y[182],
+                Y[182 + 1],
+                (double) +0.242980179903264, (double) -0.970031253194544);
+  BUTTERFLY_XY (Y[56],               /* W28 */
+                Y[56 + 1],
+                Y[184],
+                Y[184 + 1],
+                Y[56],
+                Y[56 + 1],
+                Y[184],
+                Y[184 + 1],
+                (double) +0.195090322016128, (double) -0.980785280403230);
+  BUTTERFLY_XY (Y[58],               /* W29 */
+                Y[58 + 1],
+                Y[186],
+                Y[186 + 1],
+                Y[58],
+                Y[58 + 1],
+                Y[186],
+                Y[186 + 1],
+                (double) +0.146730474455362, (double) -0.989176509964781);
+  BUTTERFLY_XY (Y[60],               /* W30 */
+                Y[60 + 1],
+                Y[188],
+                Y[188 + 1],
+                Y[60],
+                Y[60 + 1],
+                Y[188],
+                Y[188 + 1],
+                (double) +0.098017140329561, (double) -0.995184726672197);
+  BUTTERFLY_XY (Y[62],               /* W31 */
+                Y[62 + 1],
+                Y[190],
+                Y[190 + 1],
+                Y[62],
+                Y[62 + 1],
+                Y[190],
+                Y[190 + 1],
+                (double) +0.049067674327418, (double) -0.998795456205172);
+  BUTTERFLY_0m (Y[64],               /* W32 */
+                Y[64 + 1],
+                Y[192],
+                Y[192 + 1],
+                Y[64],
+                Y[64 + 1],
+                Y[192],
+                Y[192 + 1],
+                (double) +0.000000000000000, (double) -1.000000000000000);
+  BUTTERFLY_XY (Y[66],               /* W33 */
+                Y[66 + 1],
+                Y[194],
+                Y[194 + 1],
+                Y[66],
+                Y[66 + 1],
+                Y[194],
+                Y[194 + 1],
+                (double) -0.049067674327418, (double) -0.998795456205172);
+  BUTTERFLY_XY (Y[68],               /* W34 */
+                Y[68 + 1],
+                Y[196],
+                Y[196 + 1],
+                Y[68],
+                Y[68 + 1],
+                Y[196],
+                Y[196 + 1],
+                (double) -0.098017140329561, (double) -0.995184726672197);
+  BUTTERFLY_XY (Y[70],               /* W35 */
+                Y[70 + 1],
+                Y[198],
+                Y[198 + 1],
+                Y[70],
+                Y[70 + 1],
+                Y[198],
+                Y[198 + 1],
+                (double) -0.146730474455362, (double) -0.989176509964781);
+  BUTTERFLY_XY (Y[72],               /* W36 */
+                Y[72 + 1],
+                Y[200],
+                Y[200 + 1],
+                Y[72],
+                Y[72 + 1],
+                Y[200],
+                Y[200 + 1],
+                (double) -0.195090322016128, (double) -0.980785280403230);
+  BUTTERFLY_XY (Y[74],               /* W37 */
+                Y[74 + 1],
+                Y[202],
+                Y[202 + 1],
+                Y[74],
+                Y[74 + 1],
+                Y[202],
+                Y[202 + 1],
+                (double) -0.242980179903264, (double) -0.970031253194544);
+  BUTTERFLY_XY (Y[76],               /* W38 */
+                Y[76 + 1],
+                Y[204],
+                Y[204 + 1],
+                Y[76],
+                Y[76 + 1],
+                Y[204],
+                Y[204 + 1],
+                (double) -0.290284677254462, (double) -0.956940335732209);
+  BUTTERFLY_XY (Y[78],               /* W39 */
+                Y[78 + 1],
+                Y[206],
+                Y[206 + 1],
+                Y[78],
+                Y[78 + 1],
+                Y[206],
+                Y[206 + 1],
+                (double) -0.336889853392220, (double) -0.941544065183021);
+  BUTTERFLY_XY (Y[80],               /* W40 */
+                Y[80 + 1],
+                Y[208],
+                Y[208 + 1],
+                Y[80],
+                Y[80 + 1],
+                Y[208],
+                Y[208 + 1],
+                (double) -0.382683432365090, (double) -0.923879532511287);
+  BUTTERFLY_XY (Y[82],               /* W41 */
+                Y[82 + 1],
+                Y[210],
+                Y[210 + 1],
+                Y[82],
+                Y[82 + 1],
+                Y[210],
+                Y[210 + 1],
+                (double) -0.427555093430282, (double) -0.903989293123443);
+  BUTTERFLY_XY (Y[84],               /* W42 */
+                Y[84 + 1],
+                Y[212],
+                Y[212 + 1],
+                Y[84],
+                Y[84 + 1],
+                Y[212],
+                Y[212 + 1],
+                (double) -0.471396736825998, (double) -0.881921264348355);
+  BUTTERFLY_XY (Y[86],               /* W43 */
+                Y[86 + 1],
+                Y[214],
+                Y[214 + 1],
+                Y[86],
+                Y[86 + 1],
+                Y[214],
+                Y[214 + 1],
+                (double) -0.514102744193222, (double) -0.857728610000272);
+  BUTTERFLY_XY (Y[88],               /* W44 */
+                Y[88 + 1],
+                Y[216],
+                Y[216 + 1],
+                Y[88],
+                Y[88 + 1],
+                Y[216],
+                Y[216 + 1],
+                (double) -0.555570233019602, (double) -0.831469612302545);
+  BUTTERFLY_XY (Y[90],               /* W45 */
+                Y[90 + 1],
+                Y[218],
+                Y[218 + 1],
+                Y[90],
+                Y[90 + 1],
+                Y[218],
+                Y[218 + 1],
+                (double) -0.595699304492433, (double) -0.803207531480645);
+  BUTTERFLY_XY (Y[92],               /* W46 */
+                Y[92 + 1],
+                Y[220],
+                Y[220 + 1],
+                Y[92],
+                Y[92 + 1],
+                Y[220],
+                Y[220 + 1],
+                (double) -0.634393284163645, (double) -0.773010453362737);
+  BUTTERFLY_XY (Y[94],               /* W47 */
+                Y[94 + 1],
+                Y[222],
+                Y[222 + 1],
+                Y[94],
+                Y[94 + 1],
+                Y[222],
+                Y[222 + 1],
+                (double) -0.671558954847018, (double) -0.740951125354959);
+  BUTTERFLY_XX (Y[96],               /* W48 */
+                Y[96 + 1],
+                Y[224],
+                Y[224 + 1],
+                Y[96],
+                Y[96 + 1],
+                Y[224],
+                Y[224 + 1],
+                (double) -0.707106781186547, (double) -0.707106781186548);
+  BUTTERFLY_XY (Y[98],               /* W49 */
+                Y[98 + 1],
+                Y[226],
+                Y[226 + 1],
+                Y[98],
+                Y[98 + 1],
+                Y[226],
+                Y[226 + 1],
+                (double) -0.740951125354959, (double) -0.671558954847019);
+  BUTTERFLY_XY (Y[100],               /* W50 */
+                Y[100 + 1],
+                Y[228],
+                Y[228 + 1],
+                Y[100],
+                Y[100 + 1],
+                Y[228],
+                Y[228 + 1],
+                (double) -0.773010453362737, (double) -0.634393284163645);
+  BUTTERFLY_XY (Y[102],               /* W51 */
+                Y[102 + 1],
+                Y[230],
+                Y[230 + 1],
+                Y[102],
+                Y[102 + 1],
+                Y[230],
+                Y[230 + 1],
+                (double) -0.803207531480645, (double) -0.595699304492433);
+  BUTTERFLY_XY (Y[104],               /* W52 */
+                Y[104 + 1],
+                Y[232],
+                Y[232 + 1],
+                Y[104],
+                Y[104 + 1],
+                Y[232],
+                Y[232 + 1],
+                (double) -0.831469612302545, (double) -0.555570233019602);
+  BUTTERFLY_XY (Y[106],               /* W53 */
+                Y[106 + 1],
+                Y[234],
+                Y[234 + 1],
+                Y[106],
+                Y[106 + 1],
+                Y[234],
+                Y[234 + 1],
+                (double) -0.857728610000272, (double) -0.514102744193222);
+  BUTTERFLY_XY (Y[108],               /* W54 */
+                Y[108 + 1],
+                Y[236],
+                Y[236 + 1],
+                Y[108],
+                Y[108 + 1],
+                Y[236],
+                Y[236 + 1],
+                (double) -0.881921264348355, (double) -0.471396736825998);
+  BUTTERFLY_XY (Y[110],               /* W55 */
+                Y[110 + 1],
+                Y[238],
+                Y[238 + 1],
+                Y[110],
+                Y[110 + 1],
+                Y[238],
+                Y[238 + 1],
+                (double) -0.903989293123443, (double) -0.427555093430282);
+  BUTTERFLY_XY (Y[112],               /* W56 */
+                Y[112 + 1],
+                Y[240],
+                Y[240 + 1],
+                Y[112],
+                Y[112 + 1],
+                Y[240],
+                Y[240 + 1],
+                (double) -0.923879532511287, (double) -0.382683432365090);
+  BUTTERFLY_XY (Y[114],               /* W57 */
+                Y[114 + 1],
+                Y[242],
+                Y[242 + 1],
+                Y[114],
+                Y[114 + 1],
+                Y[242],
+                Y[242 + 1],
+                (double) -0.941544065183021, (double) -0.336889853392220);
+  BUTTERFLY_XY (Y[116],               /* W58 */
+                Y[116 + 1],
+                Y[244],
+                Y[244 + 1],
+                Y[116],
+                Y[116 + 1],
+                Y[244],
+                Y[244 + 1],
+                (double) -0.956940335732209, (double) -0.290284677254462);
+  BUTTERFLY_XY (Y[118],               /* W59 */
+                Y[118 + 1],
+                Y[246],
+                Y[246 + 1],
+                Y[118],
+                Y[118 + 1],
+                Y[246],
+                Y[246 + 1],
+                (double) -0.970031253194544, (double) -0.242980179903264);
+  BUTTERFLY_XY (Y[120],               /* W60 */
+                Y[120 + 1],
+                Y[248],
+                Y[248 + 1],
+                Y[120],
+                Y[120 + 1],
+                Y[248],
+                Y[248 + 1],
+                (double) -0.980785280403230, (double) -0.195090322016129);
+  BUTTERFLY_XY (Y[122],               /* W61 */
+                Y[122 + 1],
+                Y[250],
+                Y[250 + 1],
+                Y[122],
+                Y[122 + 1],
+                Y[250],
+                Y[250 + 1],
+                (double) -0.989176509964781, (double) -0.146730474455362);
+  BUTTERFLY_XY (Y[124],               /* W62 */
+                Y[124 + 1],
+                Y[252],
+                Y[252 + 1],
+                Y[124],
+                Y[124 + 1],
+                Y[252],
+                Y[252 + 1],
+                (double) -0.995184726672197, (double) -0.098017140329561);
+  BUTTERFLY_XY (Y[126],               /* W63 */
+                Y[126 + 1],
+                Y[254],
+                Y[254 + 1],
+                Y[126],
+                Y[126 + 1],
+                Y[254],
+                Y[254 + 1],
+                (double) -0.998795456205172, (double) -0.049067674327418);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 128 L S S S S S X)
+ **/
+static void
+gsl_power2_fft128synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2synthesis (128, X, Y);
+
+  /* skipping 32 times fft4 */
+
+  /* skipping 16 times fft8 */
+
+  /* skipping 8 times fft16 */
+
+  /* skipping 4 times fft32 */
+
+  /* skipping 2 times fft64 */
+
+  /* perform 1 times fft128 */
+  gsl_power2_fft128synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 256 S S S S S S X T)
+ **/
+static void
+gsl_power2_fft256synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 128 times fft2 */
+
+  /* skipping 64 times fft4 */
+
+  /* skipping 32 times fft8 */
+
+  /* skipping 16 times fft16 */
+
+  /* skipping 8 times fft32 */
+
+  /* skipping 4 times fft64 */
+
+  /* perform 2 times fft128 */
+  gsl_power2_fft128synthesis_skip2 (X, Y);
+  gsl_power2_fft128synthesis_skip2 (X + 256, Y + 256);
+
+  /* perform 1 times fft256 */
+  {
+    static const double Wconst256[] = {
+      +0.999698818696204, -0.024541228522912,
+      +0.998795456205172, -0.049067674327418,
+      +0.997290456678690, -0.073564563599667,
+      +0.995184726672197, -0.098017140329561,
+      +0.992479534598710, -0.122410675199216,
+      +0.989176509964781, -0.146730474455362,
+      +0.985277642388941, -0.170961888760301,
+      +0.980785280403230, -0.195090322016128,
+      +0.975702130038529, -0.219101240156870,
+      +0.970031253194544, -0.242980179903264,
+      +0.963776065795440, -0.266712757474898,
+      +0.956940335732209, -0.290284677254462,
+      +0.949528180593037, -0.313681740398892,
+      +0.941544065183021, -0.336889853392220,
+      +0.932992798834739, -0.359895036534988,
+      +0.923879532511287, -0.382683432365090,
+      +0.914209755703531, -0.405241314004990,
+      +0.903989293123443, -0.427555093430282,
+      +0.893224301195515, -0.449611329654607,
+      +0.881921264348355, -0.471396736825998,
+      +0.870086991108711, -0.492898192229784,
+      +0.857728610000272, -0.514102744193222,
+      +0.844853565249707, -0.534997619887097,
+      +0.831469612302545, -0.555570233019602,
+      +0.817584813151584, -0.575808191417845,
+      +0.803207531480645, -0.595699304492433,
+      +0.788346427626606, -0.615231590580627,
+      +0.773010453362737, -0.634393284163645,
+      +0.757208846506485, -0.653172842953777,
+      +0.740951125354959, -0.671558954847018,
+      +0.724247082951467, -0.689540544737067,
+      +0.707106781186548, -0.707106781186547,
+      +0.689540544737067, -0.724247082951467,
+      +0.671558954847018, -0.740951125354959,
+      +0.653172842953777, -0.757208846506484,
+      +0.634393284163645, -0.773010453362737,
+      +0.615231590580627, -0.788346427626606,
+      +0.595699304492433, -0.803207531480645,
+      +0.575808191417845, -0.817584813151584,
+      +0.555570233019602, -0.831469612302545,
+      +0.534997619887097, -0.844853565249707,
+      +0.514102744193222, -0.857728610000272,
+      +0.492898192229784, -0.870086991108711,
+      +0.471396736825998, -0.881921264348355,
+      +0.449611329654607, -0.893224301195515,
+      +0.427555093430282, -0.903989293123443,
+      +0.405241314004990, -0.914209755703531,
+      +0.382683432365090, -0.923879532511287,
+      +0.359895036534988, -0.932992798834739,
+      +0.336889853392220, -0.941544065183021,
+      +0.313681740398892, -0.949528180593037,
+      +0.290284677254462, -0.956940335732209,
+      +0.266712757474898, -0.963776065795440,
+      +0.242980179903264, -0.970031253194544,
+      +0.219101240156870, -0.975702130038529,
+      +0.195090322016128, -0.980785280403230,
+      +0.170961888760301, -0.985277642388941,
+      +0.146730474455362, -0.989176509964781,
+      +0.122410675199216, -0.992479534598710,
+      +0.098017140329561, -0.995184726672197,
+      +0.073564563599667, -0.997290456678690,
+      +0.049067674327418, -0.998795456205172,
+      +0.024541228522912, -0.999698818696204,
+    };
+    const double *W = Wconst256 - 2;
+    double *Z = Y + 128;
+    for (offset = 0; offset < 512; offset += 512) {
+      BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                    Y[offset + 256], Y[offset + 256 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 256], Y[offset + 256 + 1],
+                    __1, __0);
+      BUTTERFLY_0m (Z[offset], Z[offset + 1],
+                    Z[offset + 256], Z[offset + 256 + 1],
+                    Z[offset], Z[offset + 1],
+                    Z[offset + 256], Z[offset + 256 + 1],
+                    __0, __1);
+    }
+    for (butterfly = 2; butterfly < 128; butterfly += 2) {
+      Wre = W[butterfly]; Wim = W[butterfly + 1];
+      for (block = 0; block < 512; block += 512) {
+        offset = butterfly + block;
+        BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                      Y[offset + 256], Y[offset + 256 + 1],
+                      Y[offset], Y[offset + 1],
+                      Y[offset + 256], Y[offset + 256 + 1],
+                      Wre, Wim);
+        BUTTERFLY_yX (Z[offset], Z[offset + 1],
+                      Z[offset + 256], Z[offset + 256 + 1],
+                      Z[offset], Z[offset + 1],
+                      Z[offset + 256], Z[offset + 256 + 1],
+                      Wre, Wim);
+      }
+    }
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 256 L S S S S S S X)
+ **/
+static void
+gsl_power2_fft256synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2synthesis (256, X, Y);
+
+  /* skipping 64 times fft4 */
+
+  /* skipping 32 times fft8 */
+
+  /* skipping 16 times fft16 */
+
+  /* skipping 8 times fft32 */
+
+  /* skipping 4 times fft64 */
+
+  /* skipping 2 times fft128 */
+
+  /* perform 1 times fft256 */
+  gsl_power2_fft256synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 512 S S S S S S X T T)
+ **/
+static void
+gsl_power2_fft512synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 256 times fft2 */
+
+  /* skipping 128 times fft4 */
+
+  /* skipping 64 times fft8 */
+
+  /* skipping 32 times fft16 */
+
+  /* skipping 16 times fft32 */
+
+  /* skipping 8 times fft64 */
+
+  /* perform 4 times fft128 */
+  gsl_power2_fft128synthesis_skip2 (X, Y);
+  gsl_power2_fft128synthesis_skip2 (X + 256, Y + 256);
+  gsl_power2_fft128synthesis_skip2 (X + 512, Y + 512);
+  gsl_power2_fft128synthesis_skip2 (X + 768, Y + 768);
+
+  /* perform 2 times fft256 */
+  {
+    static const double Wconst256[] = {
+      +0.999698818696204, -0.024541228522912,
+      +0.998795456205172, -0.049067674327418,
+      +0.997290456678690, -0.073564563599667,
+      +0.995184726672197, -0.098017140329561,
+      +0.992479534598710, -0.122410675199216,
+      +0.989176509964781, -0.146730474455362,
+      +0.985277642388941, -0.170961888760301,
+      +0.980785280403230, -0.195090322016128,
+      +0.975702130038529, -0.219101240156870,
+      +0.970031253194544, -0.242980179903264,
+      +0.963776065795440, -0.266712757474898,
+      +0.956940335732209, -0.290284677254462,
+      +0.949528180593037, -0.313681740398892,
+      +0.941544065183021, -0.336889853392220,
+      +0.932992798834739, -0.359895036534988,
+      +0.923879532511287, -0.382683432365090,
+      +0.914209755703531, -0.405241314004990,
+      +0.903989293123443, -0.427555093430282,
+      +0.893224301195515, -0.449611329654607,
+      +0.881921264348355, -0.471396736825998,
+      +0.870086991108711, -0.492898192229784,
+      +0.857728610000272, -0.514102744193222,
+      +0.844853565249707, -0.534997619887097,
+      +0.831469612302545, -0.555570233019602,
+      +0.817584813151584, -0.575808191417845,
+      +0.803207531480645, -0.595699304492433,
+      +0.788346427626606, -0.615231590580627,
+      +0.773010453362737, -0.634393284163645,
+      +0.757208846506485, -0.653172842953777,
+      +0.740951125354959, -0.671558954847018,
+      +0.724247082951467, -0.689540544737067,
+      +0.707106781186548, -0.707106781186547,
+      +0.689540544737067, -0.724247082951467,
+      +0.671558954847018, -0.740951125354959,
+      +0.653172842953777, -0.757208846506484,
+      +0.634393284163645, -0.773010453362737,
+      +0.615231590580627, -0.788346427626606,
+      +0.595699304492433, -0.803207531480645,
+      +0.575808191417845, -0.817584813151584,
+      +0.555570233019602, -0.831469612302545,
+      +0.534997619887097, -0.844853565249707,
+      +0.514102744193222, -0.857728610000272,
+      +0.492898192229784, -0.870086991108711,
+      +0.471396736825998, -0.881921264348355,
+      +0.449611329654607, -0.893224301195515,
+      +0.427555093430282, -0.903989293123443,
+      +0.405241314004990, -0.914209755703531,
+      +0.382683432365090, -0.923879532511287,
+      +0.359895036534988, -0.932992798834739,
+      +0.336889853392220, -0.941544065183021,
+      +0.313681740398892, -0.949528180593037,
+      +0.290284677254462, -0.956940335732209,
+      +0.266712757474898, -0.963776065795440,
+      +0.242980179903264, -0.970031253194544,
+      +0.219101240156870, -0.975702130038529,
+      +0.195090322016128, -0.980785280403230,
+      +0.170961888760301, -0.985277642388941,
+      +0.146730474455362, -0.989176509964781,
+      +0.122410675199216, -0.992479534598710,
+      +0.098017140329561, -0.995184726672197,
+      +0.073564563599667, -0.997290456678690,
+      +0.049067674327418, -0.998795456205172,
+      +0.024541228522912, -0.999698818696204,
+    };
+    const double *W = Wconst256 - 2;
+    double *Z = Y + 128;
+    for (offset = 0; offset < 1024; offset += 512) {
+      BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                    Y[offset + 256], Y[offset + 256 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 256], Y[offset + 256 + 1],
+                    __1, __0);
+      BUTTERFLY_0m (Z[offset], Z[offset + 1],
+                    Z[offset + 256], Z[offset + 256 + 1],
+                    Z[offset], Z[offset + 1],
+                    Z[offset + 256], Z[offset + 256 + 1],
+                    __0, __1);
+    }
+    for (butterfly = 2; butterfly < 128; butterfly += 2) {
+      Wre = W[butterfly]; Wim = W[butterfly + 1];
+      for (block = 0; block < 1024; block += 512) {
+        offset = butterfly + block;
+        BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                      Y[offset + 256], Y[offset + 256 + 1],
+                      Y[offset], Y[offset + 1],
+                      Y[offset + 256], Y[offset + 256 + 1],
+                      Wre, Wim);
+        BUTTERFLY_yX (Z[offset], Z[offset + 1],
+                      Z[offset + 256], Z[offset + 256 + 1],
+                      Z[offset], Z[offset + 1],
+                      Z[offset + 256], Z[offset + 256 + 1],
+                      Wre, Wim);
+      }
+    }
+  }
+
+  /* perform 1 times fft512 */
+  {
+    static const double Wconst512[] = {
+      +0.999924701839145, -0.012271538285720,
+      +0.999698818696204, -0.024541228522912,
+      +0.999322384588350, -0.036807222941359,
+      +0.998795456205172, -0.049067674327418,
+      +0.998118112900149, -0.061320736302209,
+      +0.997290456678690, -0.073564563599667,
+      +0.996312612182778, -0.085797312344440,
+      +0.995184726672197, -0.098017140329561,
+      +0.993906970002356, -0.110222207293883,
+      +0.992479534598710, -0.122410675199216,
+      +0.990902635427780, -0.134580708507126,
+      +0.989176509964781, -0.146730474455362,
+      +0.987301418157858, -0.158858143333861,
+      +0.985277642388941, -0.170961888760301,
+      +0.983105487431216, -0.183039887955141,
+      +0.980785280403230, -0.195090322016128,
+      +0.978317370719628, -0.207111376192219,
+      +0.975702130038529, -0.219101240156870,
+      +0.972939952205560, -0.231058108280671,
+      +0.970031253194544, -0.242980179903264,
+      +0.966976471044852, -0.254865659604515,
+      +0.963776065795440, -0.266712757474898,
+      +0.960430519415566, -0.278519689385053,
+      +0.956940335732209, -0.290284677254462,
+      +0.953306040354194, -0.302005949319228,
+      +0.949528180593037, -0.313681740398892,
+      +0.945607325380521, -0.325310292162263,
+      +0.941544065183021, -0.336889853392220,
+      +0.937339011912575, -0.348418680249435,
+      +0.932992798834739, -0.359895036534988,
+      +0.928506080473216, -0.371317193951838,
+      +0.923879532511287, -0.382683432365090,
+      +0.919113851690058, -0.393992040061048,
+      +0.914209755703531, -0.405241314004990,
+      +0.909167983090522, -0.416429560097637,
+      +0.903989293123443, -0.427555093430282,
+      +0.898674465693954, -0.438616238538528,
+      +0.893224301195515, -0.449611329654607,
+      +0.887639620402854, -0.460538710958240,
+      +0.881921264348355, -0.471396736825998,
+      +0.876070094195407, -0.482183772079123,
+      +0.870086991108711, -0.492898192229784,
+      +0.863972856121587, -0.503538383725718,
+      +0.857728610000272, -0.514102744193222,
+      +0.851355193105265, -0.524589682678469,
+      +0.844853565249707, -0.534997619887097,
+      +0.838224705554838, -0.545324988422046,
+      +0.831469612302545, -0.555570233019602,
+      +0.824589302785025, -0.565731810783613,
+      +0.817584813151584, -0.575808191417845,
+      +0.810457198252595, -0.585797857456439,
+      +0.803207531480645, -0.595699304492433,
+      +0.795836904608884, -0.605511041404326,
+      +0.788346427626606, -0.615231590580627,
+      +0.780737228572094, -0.624859488142386,
+      +0.773010453362737, -0.634393284163645,
+      +0.765167265622459, -0.643831542889791,
+      +0.757208846506485, -0.653172842953777,
+      +0.749136394523459, -0.662415777590172,
+      +0.740951125354959, -0.671558954847018,
+      +0.732654271672413, -0.680600997795453,
+      +0.724247082951467, -0.689540544737067,
+      +0.715730825283819, -0.698376249408973,
+      +0.707106781186548, -0.707106781186547,
+      +0.698376249408973, -0.715730825283819,
+      +0.689540544737067, -0.724247082951467,
+      +0.680600997795453, -0.732654271672413,
+      +0.671558954847018, -0.740951125354959,
+      +0.662415777590172, -0.749136394523459,
+      +0.653172842953777, -0.757208846506484,
+      +0.643831542889791, -0.765167265622459,
+      +0.634393284163645, -0.773010453362737,
+      +0.624859488142386, -0.780737228572094,
+      +0.615231590580627, -0.788346427626606,
+      +0.605511041404326, -0.795836904608883,
+      +0.595699304492433, -0.803207531480645,
+      +0.585797857456439, -0.810457198252595,
+      +0.575808191417845, -0.817584813151584,
+      +0.565731810783613, -0.824589302785025,
+      +0.555570233019602, -0.831469612302545,
+      +0.545324988422046, -0.838224705554838,
+      +0.534997619887097, -0.844853565249707,
+      +0.524589682678469, -0.851355193105265,
+      +0.514102744193222, -0.857728610000272,
+      +0.503538383725718, -0.863972856121587,
+      +0.492898192229784, -0.870086991108711,
+      +0.482183772079123, -0.876070094195407,
+      +0.471396736825998, -0.881921264348355,
+      +0.460538710958240, -0.887639620402854,
+      +0.449611329654607, -0.893224301195515,
+      +0.438616238538528, -0.898674465693954,
+      +0.427555093430282, -0.903989293123443,
+      +0.416429560097637, -0.909167983090522,
+      +0.405241314004990, -0.914209755703531,
+      +0.393992040061048, -0.919113851690058,
+      +0.382683432365090, -0.923879532511287,
+      +0.371317193951838, -0.928506080473215,
+      +0.359895036534988, -0.932992798834739,
+      +0.348418680249435, -0.937339011912575,
+      +0.336889853392220, -0.941544065183021,
+      +0.325310292162263, -0.945607325380521,
+      +0.313681740398892, -0.949528180593037,
+      +0.302005949319228, -0.953306040354194,
+      +0.290284677254462, -0.956940335732209,
+      +0.278519689385053, -0.960430519415566,
+      +0.266712757474898, -0.963776065795440,
+      +0.254865659604515, -0.966976471044852,
+      +0.242980179903264, -0.970031253194544,
+      +0.231058108280671, -0.972939952205560,
+      +0.219101240156870, -0.975702130038529,
+      +0.207111376192219, -0.978317370719628,
+      +0.195090322016128, -0.980785280403230,
+      +0.183039887955141, -0.983105487431216,
+      +0.170961888760301, -0.985277642388941,
+      +0.158858143333861, -0.987301418157858,
+      +0.146730474455362, -0.989176509964781,
+      +0.134580708507126, -0.990902635427780,
+      +0.122410675199216, -0.992479534598710,
+      +0.110222207293883, -0.993906970002356,
+      +0.098017140329561, -0.995184726672197,
+      +0.085797312344440, -0.996312612182778,
+      +0.073564563599667, -0.997290456678690,
+      +0.061320736302209, -0.998118112900149,
+      +0.049067674327418, -0.998795456205172,
+      +0.036807222941359, -0.999322384588350,
+      +0.024541228522912, -0.999698818696204,
+      +0.012271538285720, -0.999924701839145,
+    };
+    const double *W = Wconst512 - 2;
+    double *Z = Y + 256;
+    for (offset = 0; offset < 1024; offset += 1024) {
+      BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                    Y[offset + 512], Y[offset + 512 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 512], Y[offset + 512 + 1],
+                    __1, __0);
+      BUTTERFLY_0m (Z[offset], Z[offset + 1],
+                    Z[offset + 512], Z[offset + 512 + 1],
+                    Z[offset], Z[offset + 1],
+                    Z[offset + 512], Z[offset + 512 + 1],
+                    __0, __1);
+    }
+    for (butterfly = 2; butterfly < 256; butterfly += 2) {
+      Wre = W[butterfly]; Wim = W[butterfly + 1];
+      for (block = 0; block < 1024; block += 1024) {
+        offset = butterfly + block;
+        BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                      Y[offset + 512], Y[offset + 512 + 1],
+                      Y[offset], Y[offset + 1],
+                      Y[offset + 512], Y[offset + 512 + 1],
+                      Wre, Wim);
+        BUTTERFLY_yX (Z[offset], Z[offset + 1],
+                      Z[offset + 512], Z[offset + 512 + 1],
+                      Z[offset], Z[offset + 1],
+                      Z[offset + 512], Z[offset + 512 + 1],
+                      Wre, Wim);
+      }
+    }
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 512 L S S S S S S S X)
+ **/
+static void
+gsl_power2_fft512synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2synthesis (512, X, Y);
+
+  /* skipping 128 times fft4 */
+
+  /* skipping 64 times fft8 */
+
+  /* skipping 32 times fft16 */
+
+  /* skipping 16 times fft32 */
+
+  /* skipping 8 times fft64 */
+
+  /* skipping 4 times fft128 */
+
+  /* skipping 2 times fft256 */
+
+  /* perform 1 times fft512 */
+  gsl_power2_fft512synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 1024 S S S S S S S S X L)
+ **/
+static void
+gsl_power2_fft1024synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 512 times fft2 */
+
+  /* skipping 256 times fft4 */
+
+  /* skipping 128 times fft8 */
+
+  /* skipping 64 times fft16 */
+
+  /* skipping 32 times fft32 */
+
+  /* skipping 16 times fft64 */
+
+  /* skipping 8 times fft128 */
+
+  /* skipping 4 times fft256 */
+
+  /* perform 2 times fft512 */
+  gsl_power2_fft512synthesis_skip2 (X, Y);
+  gsl_power2_fft512synthesis_skip2 (X + 1024, Y + 1024);
+
+  /* perform 1 times fft1024 */
+  for (offset = 0; offset < 2048; offset += 2048) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999981175282601; Wim = -0.006135884649154;
+  for (butterfly = 2; butterfly < 512; butterfly += 2) {
+    for (block = 0; block < 2048; block += 2048) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000018824717399, -0.006135884649154);
+  }
+  for (offset = 512; offset < 2048; offset += 2048) {
+    BUTTERFLY_0m (Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  __0, __1);
+  }
+  Wre = -0.006135884649154; Wim = -0.999981175282601;
+  for (butterfly = 514; butterfly < 1024; butterfly += 2) {
+    for (block = 0; block < 2048; block += 2048) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000018824717399, -0.006135884649154);
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 1024 L S S S S S S S S X)
+ **/
+static void
+gsl_power2_fft1024synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2synthesis (1024, X, Y);
+
+  /* skipping 256 times fft4 */
+
+  /* skipping 128 times fft8 */
+
+  /* skipping 64 times fft16 */
+
+  /* skipping 32 times fft32 */
+
+  /* skipping 16 times fft64 */
+
+  /* skipping 8 times fft128 */
+
+  /* skipping 4 times fft256 */
+
+  /* skipping 2 times fft512 */
+
+  /* perform 1 times fft1024 */
+  gsl_power2_fft1024synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 2048 S S S S S S S S X L L)
+ **/
+static void
+gsl_power2_fft2048synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 1024 times fft2 */
+
+  /* skipping 512 times fft4 */
+
+  /* skipping 256 times fft8 */
+
+  /* skipping 128 times fft16 */
+
+  /* skipping 64 times fft32 */
+
+  /* skipping 32 times fft64 */
+
+  /* skipping 16 times fft128 */
+
+  /* skipping 8 times fft256 */
+
+  /* perform 4 times fft512 */
+  gsl_power2_fft512synthesis_skip2 (X, Y);
+  gsl_power2_fft512synthesis_skip2 (X + 1024, Y + 1024);
+  gsl_power2_fft512synthesis_skip2 (X + 2048, Y + 2048);
+  gsl_power2_fft512synthesis_skip2 (X + 3072, Y + 3072);
+
+  /* perform 2 times fft1024 */
+  for (offset = 0; offset < 4096; offset += 2048) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999981175282601; Wim = -0.006135884649154;
+  for (butterfly = 2; butterfly < 512; butterfly += 2) {
+    for (block = 0; block < 4096; block += 2048) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000018824717399, -0.006135884649154);
+  }
+  for (offset = 512; offset < 4096; offset += 2048) {
+    BUTTERFLY_0m (Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 1024], Y[offset + 1024 + 1],
+                  __0, __1);
+  }
+  Wre = -0.006135884649154; Wim = -0.999981175282601;
+  for (butterfly = 514; butterfly < 1024; butterfly += 2) {
+    for (block = 0; block < 4096; block += 2048) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 1024], Y[offset + 1024 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000018824717399, -0.006135884649154);
+  }
+
+  /* perform 1 times fft2048 */
+  for (offset = 0; offset < 4096; offset += 4096) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 2048], Y[offset + 2048 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 2048], Y[offset + 2048 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999995293809576; Wim = -0.003067956762966;
+  for (butterfly = 2; butterfly < 1024; butterfly += 2) {
+    for (block = 0; block < 4096; block += 4096) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 2048], Y[offset + 2048 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 2048], Y[offset + 2048 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000004706190424, -0.003067956762966);
+  }
+  for (offset = 1024; offset < 4096; offset += 4096) {
+    BUTTERFLY_0m (Y[offset], Y[offset + 1],
+                  Y[offset + 2048], Y[offset + 2048 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 2048], Y[offset + 2048 + 1],
+                  __0, __1);
+  }
+  Wre = -0.003067956762966; Wim = -0.999995293809576;
+  for (butterfly = 1026; butterfly < 2048; butterfly += 2) {
+    for (block = 0; block < 4096; block += 4096) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 2048], Y[offset + 2048 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 2048], Y[offset + 2048 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000004706190424, -0.003067956762966);
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 2048 L S S S S S S S S S X)
+ **/
+static void
+gsl_power2_fft2048synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2synthesis (2048, X, Y);
+
+  /* skipping 512 times fft4 */
+
+  /* skipping 256 times fft8 */
+
+  /* skipping 128 times fft16 */
+
+  /* skipping 64 times fft32 */
+
+  /* skipping 32 times fft64 */
+
+  /* skipping 16 times fft128 */
+
+  /* skipping 8 times fft256 */
+
+  /* skipping 4 times fft512 */
+
+  /* skipping 2 times fft1024 */
+
+  /* perform 1 times fft2048 */
+  gsl_power2_fft2048synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 4096 S S S S S S S S S S X L)
+ **/
+static void
+gsl_power2_fft4096synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 2048 times fft2 */
+
+  /* skipping 1024 times fft4 */
+
+  /* skipping 512 times fft8 */
+
+  /* skipping 256 times fft16 */
+
+  /* skipping 128 times fft32 */
+
+  /* skipping 64 times fft64 */
+
+  /* skipping 32 times fft128 */
+
+  /* skipping 16 times fft256 */
+
+  /* skipping 8 times fft512 */
+
+  /* skipping 4 times fft1024 */
+
+  /* perform 2 times fft2048 */
+  gsl_power2_fft2048synthesis_skip2 (X, Y);
+  gsl_power2_fft2048synthesis_skip2 (X + 4096, Y + 4096);
+
+  /* perform 1 times fft4096 */
+  for (offset = 0; offset < 8192; offset += 8192) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 4096], Y[offset + 4096 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 4096], Y[offset + 4096 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999998823451702; Wim = -0.001533980186285;
+  for (butterfly = 2; butterfly < 2048; butterfly += 2) {
+    for (block = 0; block < 8192; block += 8192) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 4096], Y[offset + 4096 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 4096], Y[offset + 4096 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000001176548298, -0.001533980186285);
+  }
+  for (offset = 2048; offset < 8192; offset += 8192) {
+    BUTTERFLY_0m (Y[offset], Y[offset + 1],
+                  Y[offset + 4096], Y[offset + 4096 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 4096], Y[offset + 4096 + 1],
+                  __0, __1);
+  }
+  Wre = -0.001533980186285; Wim = -0.999998823451702;
+  for (butterfly = 2050; butterfly < 4096; butterfly += 2) {
+    for (block = 0; block < 8192; block += 8192) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 4096], Y[offset + 4096 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 4096], Y[offset + 4096 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000001176548298, -0.001533980186285);
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 4096 L S S S S S S S S S S X)
+ **/
+static void
+gsl_power2_fft4096synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2synthesis (4096, X, Y);
+
+  /* skipping 1024 times fft4 */
+
+  /* skipping 512 times fft8 */
+
+  /* skipping 256 times fft16 */
+
+  /* skipping 128 times fft32 */
+
+  /* skipping 64 times fft64 */
+
+  /* skipping 32 times fft128 */
+
+  /* skipping 16 times fft256 */
+
+  /* skipping 8 times fft512 */
+
+  /* skipping 4 times fft1024 */
+
+  /* skipping 2 times fft2048 */
+
+  /* perform 1 times fft4096 */
+  gsl_power2_fft4096synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 8192 S S S S S S S S S S S X L)
+ **/
+static void
+gsl_power2_fft8192synthesis_skip2 (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* skipping 4096 times fft2 */
+
+  /* skipping 2048 times fft4 */
+
+  /* skipping 1024 times fft8 */
+
+  /* skipping 512 times fft16 */
+
+  /* skipping 256 times fft32 */
+
+  /* skipping 128 times fft64 */
+
+  /* skipping 64 times fft128 */
+
+  /* skipping 32 times fft256 */
+
+  /* skipping 16 times fft512 */
+
+  /* skipping 8 times fft1024 */
+
+  /* skipping 4 times fft2048 */
+
+  /* perform 2 times fft4096 */
+  gsl_power2_fft4096synthesis_skip2 (X, Y);
+  gsl_power2_fft4096synthesis_skip2 (X + 8192, Y + 8192);
+
+  /* perform 1 times fft8192 */
+  for (offset = 0; offset < 16384; offset += 16384) {
+    BUTTERFLY_10 (Y[offset], Y[offset + 1],
+                  Y[offset + 8192], Y[offset + 8192 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 8192], Y[offset + 8192 + 1],
+                  __1, __0);
+  }
+  Wre = +0.999999705862882; Wim = -0.000766990318743;
+  for (butterfly = 2; butterfly < 4096; butterfly += 2) {
+    for (block = 0; block < 16384; block += 16384) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 8192], Y[offset + 8192 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 8192], Y[offset + 8192 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000000294137118, -0.000766990318743);
+  }
+  for (offset = 4096; offset < 16384; offset += 16384) {
+    BUTTERFLY_0m (Y[offset], Y[offset + 1],
+                  Y[offset + 8192], Y[offset + 8192 + 1],
+                  Y[offset], Y[offset + 1],
+                  Y[offset + 8192], Y[offset + 8192 + 1],
+                  __0, __1);
+  }
+  Wre = -0.000766990318743; Wim = -0.999999705862882;
+  for (butterfly = 4098; butterfly < 8192; butterfly += 2) {
+    for (block = 0; block < 16384; block += 16384) {
+      offset = butterfly + block;
+      BUTTERFLY_XY (Y[offset], Y[offset + 1],
+                    Y[offset + 8192], Y[offset + 8192 + 1],
+                    Y[offset], Y[offset + 1],
+                    Y[offset + 8192], Y[offset + 8192 + 1],
+                    Wre, Wim);
+    }
+    WMULTIPLY (Wre, Wim, -0.000000294137118, -0.000766990318743);
+  }
+}
+
+/**
+ ** Generated data ends here
+ **/
+/**
+ ** Generated data (by gsl-genfft 8192 L S S S S S S S S S S S X)
+ **/
+static void
+gsl_power2_fft8192synthesis (const double *X, double *Y)
+{
+  register unsigned int butterfly, block, offset;
+  register double Wre, Wim;
+
+  butterfly = block = offset = 0, Wre = Wim = 0.0; /* silence compiler */
+
+  /* perform fft2 and bitreverse input */
+  bitreverse_fft2synthesis (8192, X, Y);
+
+  /* skipping 2048 times fft4 */
+
+  /* skipping 1024 times fft8 */
+
+  /* skipping 512 times fft16 */
+
+  /* skipping 256 times fft32 */
+
+  /* skipping 128 times fft64 */
+
+  /* skipping 64 times fft128 */
+
+  /* skipping 32 times fft256 */
+
+  /* skipping 16 times fft512 */
+
+  /* skipping 8 times fft1024 */
+
+  /* skipping 4 times fft2048 */
+
+  /* skipping 2 times fft4096 */
+
+  /* perform 1 times fft8192 */
+  gsl_power2_fft8192synthesis_skip2 (X, Y);
+}
+
+/**
+ ** Generated data ends here
+ **/
+
+
+/* public FFT frontends and generic handling of huge fft sizes */
+
+
+static void
+gsl_power2_fftc_big (const unsigned int n_values,
+		     const double  *rivalues_in,
+		     double        *rivalues,
+                     const int          esign)
+{
+  const unsigned int n_values2 = n_values << 1;
+  double theta = esign < 0 ? -3.1415926535897932384626433832795029 : 3.1415926535897932384626433832795029;
+  unsigned int i, block_size = 8192 << 1;
+  double last_sin;
+
+  if (esign > 0)
+    {
+      if (rivalues_in)
+        bitreverse_fft2analysis (n_values, rivalues_in, rivalues);
+      for (i = 0; i < n_values; i += 8192)
+        gsl_power2_fft8192analysis_skip2 (rivalues + (i << 1), rivalues + (i << 1));
+    }
+  else
+    {
+      if (rivalues_in)
+        bitreverse_fft2synthesis (n_values, rivalues_in, rivalues);
+      for (i = 0; i < n_values; i += 8192)
+        gsl_power2_fft8192synthesis_skip2 (rivalues + (i << 1), rivalues + (i << 1));
+    }
+  theta *= (double) 1.0 / 8192.;
+  last_sin = sin (theta);
+  
+  /* we're not combining the first and second halves coefficients
+   * in the below loop, since for fft sizes beyond 8192, it'd actually
+   * harm performance due to paging
+   */
+  do
+    {
+      double Dre, Dim, Wre, Wim;
+      unsigned int k, i, half_block = block_size >> 1;
+      unsigned int block_size2 = block_size << 1;
+
+      theta *= 0.5;
+      Dim = last_sin;
+      last_sin = sin (theta);
+      Dre = last_sin * last_sin * -2.;
+      
+      /* loop over first coefficient in each block ==> w == {1,0} */
+      for (i = 0; i < n_values2; i += block_size2)
+	{
+	  unsigned int v1 = i, v2 = i + block_size;
+
+          BUTTERFLY_10 (rivalues[v1], rivalues[v1 + 1],
+                        rivalues[v2], rivalues[v2 + 1],
+                        rivalues[v1], rivalues[v1 + 1],
+                        rivalues[v2], rivalues[v2 + 1],
+                        __1, __0);
+	}
+      Wre = Dre + 1.0;	/* update Wk */
+      Wim = Dim;	/* update Wk */
+      /* loop for every Wk in the first half of each subblock */
+      for (k = 2; k < half_block; k += 2)
+	{
+	  /* loop over kth coefficient in each block */
+	  for (i = k; i < n_values2; i += block_size2)
+	    {
+	      unsigned int v1 = i, v2 = i + block_size;
+	      
+              BUTTERFLY_XY (rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            Wre, Wim);
+	    }
+	  WMULTIPLY (Wre, Wim, Dre, Dim);	/* update Wk */
+	}
+      /* handle middle coefficient ==> w == {0,+-1} */
+      if (k < block_size)
+	{
+	  /* loop over kth coefficient in each block */
+	  if (esign > 0)
+	    for (i = k; i < n_values2; i += block_size2)
+	      {
+	        unsigned int v1 = i, v2 = i + block_size;
+	      
+                BUTTERFLY_01 (rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              __0, __1);
+	      }
+	  else
+	    for (i = k; i < n_values2; i += block_size2)
+	      {
+	        unsigned int v1 = i, v2 = i + block_size;
+	      
+                BUTTERFLY_0m (rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              __0, __1);
+	      }
+	  /* update Wk */
+	  if (esign > 0)
+	    {
+	      Wre = -Dim;
+	      Wim = Dre + 1.0;
+	    }
+	  else
+	    {
+	      Wre = Dim;
+	      Wim = -Dre - 1.0;
+	    }
+	  k += 2;
+	}
+      /* loop for every Wk in the second half of each subblock */
+      for (; k < block_size; k += 2)
+	{
+	  /* loop over kth coefficient in each block */
+	  for (i = k; i < n_values2; i += block_size2)
+	    {
+	      unsigned int v1 = i, v2 = i + block_size;
+
+              BUTTERFLY_XY (rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            Wre, Wim);
+	    }
+	  WMULTIPLY (Wre, Wim, Dre, Dim);	/* update Wk */
+	}
+      block_size = block_size2;
+    }
+  while (block_size <= n_values);
+}
+void
+gsl_power2_fftac (const unsigned int n_values,
+                  const double  *rivalues_in,
+                  double        *rivalues_out)
+{
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 1);
+  
+  switch (n_values)
+    {
+      case    1: rivalues_out[0] = rivalues_in[0], rivalues_out[1] = rivalues_in[1]; break;
+      case    2: gsl_power2_fft2analysis (rivalues_in, rivalues_out);		break;
+      case    4: gsl_power2_fft4analysis (rivalues_in, rivalues_out);		break;
+      case    8: gsl_power2_fft8analysis (rivalues_in, rivalues_out);		break;
+      case   16: gsl_power2_fft16analysis (rivalues_in, rivalues_out);		break;
+      case   32: gsl_power2_fft32analysis (rivalues_in, rivalues_out);		break;
+      case   64: gsl_power2_fft64analysis (rivalues_in, rivalues_out);		break;
+      case  128: gsl_power2_fft128analysis (rivalues_in, rivalues_out);		break;
+      case  256: gsl_power2_fft256analysis (rivalues_in, rivalues_out);		break;
+      case  512: gsl_power2_fft512analysis (rivalues_in, rivalues_out);		break;
+      case 1024: gsl_power2_fft1024analysis (rivalues_in, rivalues_out);	break;
+      case 2048: gsl_power2_fft2048analysis (rivalues_in, rivalues_out);	break;
+      case 4096: gsl_power2_fft4096analysis (rivalues_in, rivalues_out);	break;
+      case 8192: gsl_power2_fft8192analysis (rivalues_in, rivalues_out);	break;
+      default:	 gsl_power2_fftc_big (n_values, rivalues_in, rivalues_out, +1);
+    }
+}
+void
+gsl_power2_fftsc (const unsigned int n_values,
+                  const double  *rivalues_in,
+                  double        *rivalues_out)
+{
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 1);
+  
+  switch (n_values)
+    {
+      case    1: rivalues_out[0] = rivalues_in[0], rivalues_out[1] = rivalues_in[1]; break;
+      case    2: gsl_power2_fft2synthesis (rivalues_in, rivalues_out);		break;
+      case    4: gsl_power2_fft4synthesis (rivalues_in, rivalues_out);		break;
+      case    8: gsl_power2_fft8synthesis (rivalues_in, rivalues_out);		break;
+      case   16: gsl_power2_fft16synthesis (rivalues_in, rivalues_out);		break;
+      case   32: gsl_power2_fft32synthesis (rivalues_in, rivalues_out);		break;
+      case   64: gsl_power2_fft64synthesis (rivalues_in, rivalues_out);		break;
+      case  128: gsl_power2_fft128synthesis (rivalues_in, rivalues_out);	break;
+      case  256: gsl_power2_fft256synthesis (rivalues_in, rivalues_out);	break;
+      case  512: gsl_power2_fft512synthesis (rivalues_in, rivalues_out);	break;
+      case 1024: gsl_power2_fft1024synthesis (rivalues_in, rivalues_out);	break;
+      case 2048: gsl_power2_fft2048synthesis (rivalues_in, rivalues_out);	break;
+      case 4096: gsl_power2_fft4096synthesis (rivalues_in, rivalues_out);	break;
+      case 8192: gsl_power2_fft8192synthesis (rivalues_in, rivalues_out);	break;
+      default:	 gsl_power2_fftc_big (n_values, rivalues_in, rivalues_out, -1);
+    }
+  /* { unsigned int i; for (i = 0; i < n_values << 1; i++) rivalues_out[i] *= (double) n_values; } */
+}
+void
+gsl_power2_fftar (const unsigned int n_values,
+                  const double  *r_values_in,
+                  double        *rivalues_out)
+{
+  unsigned int n_cvalues = n_values >> 1;
+  double Dre, Dim, Wre, Wim, theta;
+  unsigned int i;
+
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 2);
+
+  gsl_power2_fftac (n_cvalues, r_values_in, rivalues_out);
+  theta = 3.1415926535897932384626433832795029;
+  theta /= (double) n_cvalues;
+
+  Dre = sin (0.5 * theta);
+  Dim = sin (theta);
+  Dre = Dre * Dre;
+  Wre = 0.5 - Dre;
+  Dre *= -2.;
+  Wim = Dim * 0.5;
+  for (i = 2; i < n_values >> 1; i += 2)
+    {
+      double F1re, F1im, F2re, F2im, H1re, H1im, H2re, H2im;
+      unsigned int r = n_values - i;
+      double FEre = rivalues_out[i] + rivalues_out[r];
+      double FEim = rivalues_out[i + 1] - rivalues_out[r + 1];
+      double FOre = rivalues_out[r] - rivalues_out[i];
+      double FOim = rivalues_out[r + 1] + rivalues_out[i + 1];
+
+      FEre *= 0.5;
+      FEim *= 0.5;
+      F2re = FOre * Wim;
+      F2im = FOim * Wim;
+      F1re = FOre * Wre;
+      F1im = FOim * Wre;
+
+      H1im = F2im + F1re;
+      H1re = F1im - F2re;
+      H2re = F2re - F1im;
+      H2im = H1im - FEim;
+      H1re += FEre;
+      H2re += FEre;
+      H1im += FEim;
+      rivalues_out[i] = H1re;
+      rivalues_out[i + 1] = H1im;
+      rivalues_out[r] = H2re;
+      rivalues_out[r + 1] = H2im;
+      WMULTIPLY (Wre, Wim, Dre, Dim);
+    }
+  Dre = rivalues_out[0];
+  rivalues_out[0] = Dre + rivalues_out[1];
+  rivalues_out[1] = Dre - rivalues_out[1];
+}
+void
+gsl_power2_fftsr (const unsigned int n_values,
+                  const double      *rivalues_in,
+                  double            *r_values_out)
+{
+  unsigned int n_cvalues = n_values >> 1;
+  double Dre, Dim, Wre, Wim, theta, scale;
+  unsigned int i, ri;
+
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 2);
+
+  theta = -3.1415926535897932384626433832795029;
+  theta /= (double) n_cvalues;
+
+  Dre = sin (0.5 * theta);
+  Dim = sin (theta);
+  Dre = Dre * Dre;
+  Wre = 0.5 - Dre;
+  Dre *= -2.;
+  Wim = Dim * 0.5;
+  for (i = 2, ri = 0; i < n_values >> 1; i += 2)
+    {
+      double F1re, F1im, F2re, F2im, H1re, H1im, H2re, H2im;
+      unsigned int g = n_values - i, j = n_values >> 2, rg = n_values - (ri << 1) - 2;
+      double FEre = rivalues_in[i] + rivalues_in[g];
+      double FEim = rivalues_in[i + 1] - rivalues_in[g + 1];
+      double FOre = rivalues_in[g] - rivalues_in[i];
+      double FOim = rivalues_in[g + 1] + rivalues_in[i + 1];
+
+      while (ri >= j)
+        {
+          ri -= j;
+          j >>= 1;
+        }
+      ri |= j;
+
+      FOre = -FOre;
+      FOim = -FOim;
+      FEre *= 0.5;
+      FEim *= 0.5;
+      F2re = FOre * Wim;
+      F2im = FOim * Wim;
+      F1re = FOre * Wre;
+      F1im = FOim * Wre;
+
+      H1im = F2im + F1re;
+      H1re = F1im - F2re;
+      H2re = F2re - F1im;
+      H2im = H1im - FEim;
+      H1re += FEre;
+      H2re += FEre;
+      H1im += FEim;
+
+      j = ri << 1;
+      r_values_out[j] = H1re;
+      r_values_out[j + 1] = H1im;
+      r_values_out[rg] = H2re;
+      r_values_out[rg + 1] = H2im;
+      WMULTIPLY (Wre, Wim, Dre, Dim);
+    }
+  Dre = rivalues_in[0];
+  r_values_out[0] = Dre + rivalues_in[1];
+  r_values_out[1] = Dre - rivalues_in[1];
+  r_values_out[0] *= 0.5;
+  r_values_out[1] *= 0.5;
+  if (n_values < 4)
+    return;
+  r_values_out[2] = rivalues_in[i];
+  r_values_out[2 + 1] = rivalues_in[i + 1];
+  scale = n_cvalues;
+  scale = 1.0 / scale;
+  for (i = 0; i < n_values; i += 4)
+    BUTTERFLY_10scale (r_values_out[i], r_values_out[i + 1],
+                       r_values_out[i + 2], r_values_out[i + 3],
+                       r_values_out[i], r_values_out[i + 1],
+                       r_values_out[i + 2], r_values_out[i + 3],
+                       scale);
+  switch (n_cvalues)
+    {
+      case    2: break;
+      case    4: gsl_power2_fft4synthesis_skip2 (NULL, r_values_out);	 break;
+      case    8: gsl_power2_fft8synthesis_skip2 (NULL, r_values_out);	 break;
+      case   16: gsl_power2_fft16synthesis_skip2 (NULL, r_values_out);	 break;
+      case   32: gsl_power2_fft32synthesis_skip2 (NULL, r_values_out);	 break;
+      case   64: gsl_power2_fft64synthesis_skip2 (NULL, r_values_out);	 break;
+      case  128: gsl_power2_fft128synthesis_skip2 (NULL, r_values_out);	 break;
+      case  256: gsl_power2_fft256synthesis_skip2 (NULL, r_values_out);	 break;
+      case  512: gsl_power2_fft512synthesis_skip2 (NULL, r_values_out);	 break;
+      case 1024: gsl_power2_fft1024synthesis_skip2 (NULL, r_values_out); break;
+      case 2048: gsl_power2_fft2048synthesis_skip2 (NULL, r_values_out); break;
+      case 4096: gsl_power2_fft4096synthesis_skip2 (NULL, r_values_out); break;
+      case 8192: gsl_power2_fft8192synthesis_skip2 (NULL, r_values_out); break;
+      default:	 gsl_power2_fftc_big (n_cvalues, NULL, r_values_out, -1);
+    }
+}
+void
+gsl_power2_fftar_simple (const unsigned int n_values,
+                         const float       *real_values,
+                         float             *complex_values)
+{
+  double *rv, *cv;
+  guint i;
+
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 2);
+
+  rv = g_new (double, n_values * 2);
+  cv = rv + n_values;
+  i = n_values;
+  while (i--)
+    rv[i] = real_values[i];
+  gsl_power2_fftar (n_values, rv, cv);
+  i = n_values;
+  while (i--)
+    complex_values[i] = cv[i];
+  complex_values[n_values] = complex_values[1];
+  complex_values[1] = 0.0;
+  complex_values[n_values + 1] = 0.0;
+  g_free (rv);
+}
+void
+gsl_power2_fftsr_simple (const unsigned int n_values,
+                         const float       *complex_values,
+                         float             *real_values)
+{
+  double *cv, *rv;
+  guint i;
+
+  g_return_if_fail ((n_values & (n_values - 1)) == 0 && n_values >= 2);
+
+  cv = g_new (double, n_values * 2);
+  rv = cv + n_values;
+  i = n_values;
+  while (i--)
+    cv[i] = complex_values[i];
+  cv[1] = complex_values[n_values];
+  gsl_power2_fftsr (n_values, cv, rv);
+  i = n_values;
+  while (i--)
+    real_values[i] = rv[i];
+  g_free (cv);
+}
diff --git a/flow/gsl/gslfft.h b/flow/gsl/gslfft.h
new file mode 100644
index 0000000..63e3892
--- /dev/null
+++ b/flow/gsl/gslfft.h
@@ -0,0 +1,126 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_FFT_H__
+#define __GSL_FFT_H__
+
+#include <gsl/gsldefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/**
+ * gsl_power2_fftac
+ * @n_values:      Number of complex values
+ * @ri_values_in:  Complex sample values [0..n_values*2-1]
+ * @ri_values_out: Complex frequency values [0..n_values*2-1]
+ * This function performs a decimation in time fourier transformation
+ * in forward direction, where the input values are equidistant sampled
+ * data, and the output values contain the frequency proportions of the
+ * input.
+ * The input and output arrays are complex values with real and imaginery
+ * portions interleaved, adressable in the range [0..2*n_values-1], where
+ * n_values must be a power of two.
+ * Frequencies are stored in-order, the K-th output corresponds to the
+ * frequency K/n_values. (If you want to interpret negative frequencies,
+ * note that the frequencies -K/n_values and (n_values-K)/n_values are
+ * equivalent).
+ * Note that the transformation is performed out of place, the input
+ * array is not modified, and may not overlap with the output array.
+ */
+void	gsl_power2_fftac (const unsigned int n_values,
+			  const double      *ri_values_in,
+			  double            *ri_values_out);
+
+/**
+ * gsl_power2_fftsc
+ * @n_values:      Number of complex values
+ * @ri_values_in:  Complex frequency values [0..n_values*2-1]
+ * @ri_values_out: Complex sample values [0..n_values*2-1]
+ * This function performs a decimation in time fourier transformation
+ * in backwards direction with normalization. As such, this function
+ * represents the counterpart to gsl_power2_fftac(), that is, a value
+ * array which is transformed into the frequency domain with
+ * gsl_power2_fftac() can be reconstructed by issuing gsl_power2_fftsc()
+ * on the transform.
+ * Note that the transformation is performed out of place, the input
+ * array is not modified, and may not overlap with the output array.
+ */
+void	gsl_power2_fftsc (const unsigned int n_values,
+			  const double      *ri_values_in,
+			  double            *ri_values_out);
+
+/**
+ * gsl_power2_fftar
+ * @n_values:      Number of complex values
+ * @r_values_in:   Real sample values [0..n_values-1]
+ * @ri_values_out: Complex frequency values [0..n_values-1]
+ * Real valued variant of gsl_power2_fftac(), the input array contains
+ * real valued equidistant sampled data [0..n_values-1], and the output
+ * array contains the positive frequency half of the complex valued
+ * fourier transform. Note, that the complex valued fourier transform H
+ * of a purely real valued set of data, satisfies H(-f) = Conj(H(f)),
+ * where Conj() denotes the complex conjugate, so that just the positive
+ * frequency half suffices to describe the entire frequency spectrum.
+ * Even so, the resulting n_values/2 complex frequencies are one value
+ * off in storage size, but the resulting frequencies H(0) and
+ * H(n_values/2) are both real valued, so the real portion of
+ * H(n_values/2) is stored in ri_values_out[1] (the imaginery part of
+ * H(0)), so that both r_values_in and ri_values_out can be of size
+ * n_values.
+ * Note that the transformation is performed out of place, the input
+ * array is not modified, and may not overlap with the output array.
+ */
+void	gsl_power2_fftar (const unsigned int n_values,
+			  const double      *r_values_in,
+			  double            *ri_values_out);
+
+/**
+ * gsl_power2_fftsr
+ * @n_values:     Number of complex values
+ * @ri_values_in: Complex frequency values [0..n_values-1]
+ * @r_values_out: Real sample values [0..n_values-1]
+ * Real valued variant of gsl_power2_fftsc(), counterpart to
+ * gsl_power2_fftar(), using the same frequency storage format.
+ * A real valued data set transformed into the frequency domain
+ * with gsl_power2_fftar() can be reconstructed using this function.
+ * Note that the transformation is performed out of place, the input
+ * array is not modified, and may not overlap with the output array.
+ */
+void	gsl_power2_fftsr (const unsigned int n_values,
+			  const double      *ri_values_in,
+			  double            *r_values_out);
+
+
+/* --- convenience wrappers --- */
+void	gsl_power2_fftar_simple	(const unsigned int n_values,
+				 const float       *real_values,
+				 float		   *complex_values);
+void	gsl_power2_fftsr_simple	(const unsigned int n_values,
+				 const float	   *complex_values,
+				 float             *real_values);
+     
+     
+     
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_FFT_H__ */   /* vim:set ts=8 sw=2 sts=2: */
diff --git a/flow/gsl/gslffttest.c b/flow/gsl/gslffttest.c
new file mode 100644
index 0000000..a568bc5
--- /dev/null
+++ b/flow/gsl/gslffttest.c
@@ -0,0 +1,435 @@
+/* GSL-GENFFT - Power2 FFT C Code Generator
+ * Copyright (C) 2001 Tim Janik
+ *
+ * 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.
+ */
+#include <gsl/gslcommon.h>
+#include <gsl/gslmath.h>
+#include <gsl/gslfft.h>
+#include <sys/time.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+#define	MAX_FFT_SIZE	(65536 * 2)
+#define	EPSILON		(4.8e-6)
+
+
+/* --- prototypes --- */
+static void	reference_power2_fftc	(unsigned int       n_values,
+					 const double      *rivalues_in,
+					 double            *rivalues_out,
+					 int                esign);
+static void	fill_rand		(guint		    n,
+					 double		   *a);
+static double	diff			(guint   	    m,
+					 guint   	    p,
+					 double 	   *a1,
+					 double 	   *a2,
+					 const gchar       *str);
+
+
+/* --- variables --- */
+static double ref_fft_in[MAX_FFT_SIZE] = { 0, };
+static double ref_fft_aout[MAX_FFT_SIZE] = { 0, };
+static double ref_fft_sout[MAX_FFT_SIZE] = { 0, };
+static double work_fft_in[MAX_FFT_SIZE] = { 0, };
+static double work_fft_aout[MAX_FFT_SIZE] = { 0, };
+static double work_fft_sout[MAX_FFT_SIZE] = { 0, };
+
+
+/* --- functions --- */
+int
+main (int   argc,
+      char *argv[])
+{
+  struct timeval tv;
+  guint i;
+
+  /* initialize GSL */
+  if (!g_thread_supported ())
+      g_thread_init (NULL);
+  gsl_init (NULL, NULL);
+
+  /* initialize random numbers */
+  gettimeofday (&tv, NULL);
+  srand (tv.tv_sec ^ tv.tv_usec);
+
+  /* run tests */
+  for (i = 2; i <= MAX_FFT_SIZE >> 1; i <<= 1)
+    {
+      double d;
+
+      g_print ("Testing fft code for size %u\n", i);
+
+      /* setup reference and work fft records */
+      fill_rand (i << 1, ref_fft_in);
+      memset (ref_fft_aout, 0, MAX_FFT_SIZE * sizeof (ref_fft_aout[0]));
+      memset (ref_fft_sout, 0, MAX_FFT_SIZE * sizeof (ref_fft_sout[0]));
+      memcpy (work_fft_in, ref_fft_in, MAX_FFT_SIZE * sizeof (work_fft_in[0]));
+      memset (work_fft_aout, 0, MAX_FFT_SIZE * sizeof (work_fft_aout[0]));
+      memset (work_fft_sout, 0, MAX_FFT_SIZE * sizeof (work_fft_sout[0]));
+      reference_power2_fftc (i, ref_fft_in, ref_fft_aout, +1);
+      reference_power2_fftc (i, ref_fft_in, ref_fft_sout, -1);
+
+      /* perform fft test */
+      gsl_power2_fftac (i, work_fft_in, work_fft_aout);
+      gsl_power2_fftsc (i, work_fft_in, work_fft_sout);
+
+      /* check differences */
+      d = diff (MAX_FFT_SIZE, 0, ref_fft_in, work_fft_in, "Checking input record");
+      if (d)
+	g_error ("Reference record was modified");
+      d = diff (MAX_FFT_SIZE, 0, ref_fft_aout, work_fft_aout, "Reference analysis against GSL analysis");
+      if (fabs (d) > EPSILON)
+	g_error ("Error sum in analysis FFT exceeds epsilon: %g > %g", d, EPSILON);
+      d = diff (MAX_FFT_SIZE, 0, ref_fft_sout, work_fft_sout, "Reference synthesis against GSL synthesis");
+      if (fabs (d) > EPSILON)
+	g_error ("Error sum in analysis FFT exceeds epsilon: %g > %g", d, EPSILON);
+    }
+
+  return 0;
+}
+
+static void
+fill_rand (guint   n,
+	   double *a)
+{
+  while (n--)
+    a[n] = -1. + 2. * rand() / (RAND_MAX + 1.0);
+}
+
+static double
+diff (guint        m,
+      guint        p,
+      double      *a1,
+      double      *a2,
+      const gchar *str)
+{
+  double d = 0, max = 0, min = 1e+32;
+  guint n;
+
+  g_print ("%s\n", str);
+  for (n = 0; n < m; n++)
+    {
+      double a =  ABS (a1[n] - a2[n]);
+      if (n < p)
+	g_print ("%3u:%.3f) % 19.9f - % 19.9f = % 19.9f (% 19.9f)\n",
+		 n, ((float) n) / (float) m,
+		 a1[n], a2[n],
+		 a1[n] - a2[n],
+		 a1[n] / a2[n]);
+      d += a;
+      max = MAX (max, a);
+      min = MIN (min, a);
+    }
+  g_print ("Diff sum: %.9f, ", d);
+  g_print ("min/av/max: %.9f %.9f %.9f, ", min, d / (double) m, max);
+  g_print ("noise: %u %u %u\n",
+	   g_bit_storage (1. / min),
+	   g_bit_storage (m / d),
+	   g_bit_storage (1. / max));
+  return d;
+}
+
+
+/* --- fft implementation --- */
+#define BUTTERFLY_XY(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,Wre,Wim) { \
+  register double T1re, T1im, T2re, T2im; \
+  T1re = X2re * Wre;  \
+  T1im = X2im * Wre;  \
+  T2re = X2im * Wim;  \
+  T2im = X2re * Wim;  \
+  T1re -= T2re;       \
+  T1im += T2im;       \
+  T2re = X1re - T1re; \
+  T2im = X1im - T1im; \
+  Y1re = X1re + T1re; \
+  Y1im = X1im + T1im; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_10(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \
+  register double T2re, T2im; \
+  T2re = X1re - X2re; \
+  T2im = X1im - X2im; \
+  Y1re = X1re + X2re; \
+  Y1im = X1im + X2im; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_01(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \
+  register double T2re, T2im; \
+  T2re = X1re + X2im; \
+  T2im = X1im - X2re; \
+  Y1re = X1re - X2im; \
+  Y1im = X1im + X2re; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_0m(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,_1,_2) { \
+  register double T2re, T2im; \
+  T2re = X1re - X2im; \
+  T2im = X1im + X2re; \
+  Y1re = X1re + X2im; \
+  Y1im = X1im - X2re; \
+  Y2re = T2re;        \
+  Y2im = T2im;        \
+}
+#define BUTTERFLY_10scale(X1re,X1im,X2re,X2im,Y1re,Y1im,Y2re,Y2im,S) { \
+  register double T2re, T2im; \
+  T2re = X1re - X2re; \
+  T2im = X1im - X2im; \
+  Y1re = X1re + X2re; \
+  Y1im = X1im + X2im; \
+  Y2re = T2re * S;    \
+  Y2im = T2im * S;    \
+  Y1re *= S;          \
+  Y1im *= S;          \
+}
+#define WMULTIPLY(Wre,Wim,Dre,Dim) { \
+  register double T1re, T1im, T2re, T2im; \
+  T1re = Wre * Dre;  \
+  T1im = Wim * Dre;  \
+  T2re = Wim * Dim;  \
+  T2im = Wre * Dim;  \
+  T1re -= T2re;      \
+  T1im += T2im;      \
+  Wre += T1re;       \
+  Wim += T1im;       \
+}
+
+static inline void
+reference_bitreverse_fft2analysis (const unsigned int n,
+				   const double      *X,
+				   double            *Y)
+{
+  const unsigned int n2 = n >> 1, n1 = n + n2, max = n >> 2;
+  unsigned int i, r;
+
+  BUTTERFLY_10 (X[0], X[1],
+		X[n], X[n + 1],
+		Y[0], Y[1],
+		Y[2], Y[3],
+		__1, __0);
+  if (n < 4)
+    return;
+  BUTTERFLY_10 (X[n2], X[n2 + 1],
+		X[n1], X[n1 + 1],
+		Y[4], Y[5],
+		Y[6], Y[7],
+		__1, __0);
+  if (n < 8)
+    return;
+  for (i = 1, r = 0; i < max; i++)
+    {
+      unsigned int k, j = n >> 1;
+
+      while (r >= j)
+	{
+	  r -= j;
+	  j >>= 1;
+	}
+      r |= j;
+
+      k = r >> 1;
+      j = i << 3;
+      BUTTERFLY_10 (X[k], X[k + 1],
+		    X[k + n], X[k + n + 1],
+		    Y[j], Y[j + 1],
+		    Y[j + 2], Y[j + 3],
+		    __1, __0);
+      k += n2;
+      j += 4;
+      BUTTERFLY_10 (X[k], X[k + 1],
+		    X[k + n], X[k + n + 1],
+		    Y[j], Y[j + 1],
+		    Y[j + 2], Y[j + 3],
+		    __1, __0);
+    }
+}
+
+static inline void
+reference_bitreverse_fft2synthesis (const unsigned int n,
+				    const double      *X,
+				    double            *Y)
+{
+  const unsigned int n2 = n >> 1, n1 = n + n2, max = n >> 2;
+  unsigned int i, r;
+  double scale = n;
+
+  scale = 1.0 / scale;
+  BUTTERFLY_10scale (X[0], X[1],
+		     X[n], X[n + 1],
+		     Y[0], Y[1],
+		     Y[2], Y[3],
+		     scale);
+  if (n < 4)
+    return;
+  BUTTERFLY_10scale (X[n2], X[n2 + 1],
+		     X[n1], X[n1 + 1],
+		     Y[4], Y[5],
+		     Y[6], Y[7],
+		     scale);
+  if (n < 8)
+    return;
+  for (i = 1, r = 0; i < max; i++)
+    {
+      unsigned int k, j = n >> 1;
+
+      while (r >= j)
+	{
+	  r -= j;
+	  j >>= 1;
+	}
+      r |= j;
+
+      k = r >> 1;
+      j = i << 3;
+      BUTTERFLY_10scale (X[k], X[k + 1],
+			 X[k + n], X[k + n + 1],
+			 Y[j], Y[j + 1],
+			 Y[j + 2], Y[j + 3],
+			 scale);
+      k += n2;
+      j += 4;
+      BUTTERFLY_10scale (X[k], X[k + 1],
+			 X[k + n], X[k + n + 1],
+			 Y[j], Y[j + 1],
+			 Y[j + 2], Y[j + 3],
+			 scale);
+    }
+}
+
+static void
+reference_power2_fftc (unsigned int  n_values,
+		       const double *rivalues_in,
+		       double       *rivalues,
+		       int           esign)
+{
+  const unsigned int n_values2 = n_values << 1;
+  double theta = esign < 0 ? -3.1415926535897932384626433832795029 : 3.1415926535897932384626433832795029;
+  unsigned int block_size = 2 << 1;
+  double last_sin;
+
+  if (esign > 0)
+    reference_bitreverse_fft2analysis (n_values, rivalues_in, rivalues);
+  else
+    reference_bitreverse_fft2synthesis (n_values, rivalues_in, rivalues);
+  theta *= (double) 1.0 / 2.;
+  last_sin = sin (theta);
+
+  if (n_values < 4)
+    return;
+
+  do
+    {
+      double Dre, Dim, Wre, Wim;
+      unsigned int k, i, half_block = block_size >> 1;
+      unsigned int block_size2 = block_size << 1;
+
+      theta *= 0.5;
+      Dim = last_sin;
+      last_sin = sin (theta);
+      Dre = last_sin * last_sin * -2.;
+
+      /* loop over first coefficient in each block ==> w == {1,0} */
+      for (i = 0; i < n_values2; i += block_size2)
+	{
+	  unsigned int v1 = i, v2 = i + block_size;
+
+          BUTTERFLY_10 (rivalues[v1], rivalues[v1 + 1],
+                        rivalues[v2], rivalues[v2 + 1],
+                        rivalues[v1], rivalues[v1 + 1],
+                        rivalues[v2], rivalues[v2 + 1],
+                        __1, __0);
+	}
+      Wre = Dre + 1.0;	/* update Wk */
+      Wim = Dim;	/* update Wk */
+      /* loop for every Wk in the first half of each subblock */
+      for (k = 2; k < half_block; k += 2)
+	{
+	  /* loop over kth coefficient in each block */
+	  for (i = k; i < n_values2; i += block_size2)
+	    {
+	      unsigned int v1 = i, v2 = i + block_size;
+
+              BUTTERFLY_XY (rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            Wre, Wim);
+	    }
+	  WMULTIPLY (Wre, Wim, Dre, Dim);	/* update Wk */
+	}
+      /* handle middle coefficient ==> w == {0,+-1} */
+      if (k < block_size)
+	{
+	  /* loop over kth coefficient in each block */
+	  if (esign > 0)
+	    for (i = k; i < n_values2; i += block_size2)
+	      {
+	        unsigned int v1 = i, v2 = i + block_size;
+
+                BUTTERFLY_01 (rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              __0, __1);
+	      }
+	  else
+	    for (i = k; i < n_values2; i += block_size2)
+	      {
+	        unsigned int v1 = i, v2 = i + block_size;
+
+                BUTTERFLY_0m (rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              rivalues[v1], rivalues[v1 + 1],
+                              rivalues[v2], rivalues[v2 + 1],
+                              __0, __1);
+	      }
+	  /* update Wk */
+	  if (esign > 0)
+	    {
+	      Wre = -Dim;
+	      Wim = Dre + 1.0;
+	    }
+	  else
+	    {
+	      Wre = Dim;
+	      Wim = -Dre - 1.0;
+	    }
+	  k += 2;
+	}
+      /* loop for every Wk in the second half of each subblock */
+      for (; k < block_size; k += 2)
+	{
+	  /* loop over kth coefficient in each block */
+	  for (i = k; i < n_values2; i += block_size2)
+	    {
+	      unsigned int v1 = i, v2 = i + block_size;
+
+              BUTTERFLY_XY (rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            rivalues[v1], rivalues[v1 + 1],
+                            rivalues[v2], rivalues[v2 + 1],
+                            Wre, Wim);
+	    }
+	  WMULTIPLY (Wre, Wim, Dre, Dim);	/* update Wk */
+	}
+      block_size = block_size2;
+    }
+  while (block_size <= n_values);
+}
diff --git a/flow/gsl/gslfilehash.c b/flow/gsl/gslfilehash.c
new file mode 100644
index 0000000..ac4c066
--- /dev/null
+++ b/flow/gsl/gslfilehash.c
@@ -0,0 +1,464 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2002 Tim Janik
+ *
+ * This library 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 library 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 "gslfilehash.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+
+
+/* macros */
+#if (GLIB_SIZEOF_LONG > 4)
+#define HASH_LONG(l)	(l + (l >> 32))
+#else
+#define HASH_LONG(l)	(l)
+#endif
+
+
+/* --- variables --- */
+static GslMutex    fdpool_mutex = { 0, };
+static GHashTable *hfile_ht = NULL;
+
+
+/* --- functions --- */
+static guint
+hfile_hash (gconstpointer key)
+{
+  const GslHFile *hfile = key;
+  guint h;
+
+  h = HASH_LONG (hfile->mtime);
+  h ^= g_str_hash (hfile->file_name);
+  h ^= HASH_LONG (hfile->n_bytes);
+
+  return h;
+}
+
+static gboolean
+hfile_equals (gconstpointer key1,
+	      gconstpointer key2)
+{
+  const GslHFile *hfile1 = key1;
+  const GslHFile *hfile2 = key2;
+
+  return (hfile1->mtime == hfile2->mtime &&
+	  hfile1->n_bytes == hfile2->n_bytes &&
+	  strcmp (hfile1->file_name, hfile2->file_name) == 0);
+}
+
+void
+_gsl_init_fd_pool (void)
+{
+  g_assert (hfile_ht == NULL);
+
+  gsl_mutex_init (&fdpool_mutex);
+  hfile_ht = g_hash_table_new (hfile_hash, hfile_equals);
+}
+
+static gboolean
+stat_fd (gint     fd,
+	 GTime   *mtime,
+	 GslLong *n_bytes)
+{
+  struct stat statbuf = { 0, };
+
+  if (fstat (fd, &statbuf) < 0)
+    return FALSE;	/* have errno */
+  if (mtime)
+    *mtime = statbuf.st_mtime;
+  if (n_bytes)
+    *n_bytes = statbuf.st_size;
+  return TRUE;
+}
+
+static gboolean
+stat_file (const gchar *file_name,
+	   GTime       *mtime,
+	   GslLong     *n_bytes)
+{
+  struct stat statbuf = { 0, };
+
+  if (stat (file_name, &statbuf) < 0)
+    return FALSE;	/* have errno */
+  if (mtime)
+    *mtime = statbuf.st_mtime;
+  if (n_bytes)
+    *n_bytes = statbuf.st_size;
+  return TRUE;
+}
+
+/**
+ * gsl_hfile_open
+ * @file_name: name of the file to open
+ * @RETURNS:   a new opened #GslHFile or NULL if an error occoured (errno set)
+ *
+ * Open a file for reading and return the associated GSL hashed file.
+ * The motivation for using a #GslHFile over normal unix file
+ * descriptors is to reduce the amount of opened unix file descriptors and
+ * to ensure thread safety upon reading offset relative byte blocks.
+ * Multiple open #GslHFiles with equal file names will share a
+ * single unix file descriptor as long as the file wasn't modified meanwhile.
+ * This function is MT-safe and may be called from any thread.
+ */
+GslHFile*
+gsl_hfile_open (const gchar *file_name)
+{
+  GslHFile key, *hfile;
+  gint ret_errno;
+
+  errno = EFAULT;
+  g_return_val_if_fail (file_name != NULL, NULL);
+
+  key.file_name = (gchar*) file_name;
+  if (!stat_file (file_name, &key.mtime, &key.n_bytes))
+    return NULL;	/* errno from stat() */
+
+  GSL_SYNC_LOCK (&fdpool_mutex);
+  hfile = g_hash_table_lookup (hfile_ht, &key);
+  if (hfile)
+    {
+      GSL_SYNC_LOCK (&hfile->mutex);
+      hfile->ocount++;
+      GSL_SYNC_UNLOCK (&hfile->mutex);
+      ret_errno = 0;
+    }
+  else
+    {
+      gint fd;
+
+      fd = open (file_name, O_RDONLY | O_NOCTTY, 0);
+      if (fd >= 0)
+	{
+	  hfile = gsl_new_struct0 (GslHFile, 1);
+	  hfile->file_name = g_strdup (file_name);
+	  hfile->mtime = key.mtime;
+	  hfile->n_bytes = key.n_bytes;
+	  hfile->cpos = 0;
+	  hfile->fd = fd;
+	  hfile->ocount = 1;
+	  gsl_mutex_init (&hfile->mutex);
+	  g_hash_table_insert (hfile_ht, hfile, hfile);
+	  ret_errno = 0;
+	}
+      else
+	ret_errno = errno;
+    }
+  GSL_SYNC_UNLOCK (&fdpool_mutex);
+
+  errno = ret_errno;
+  return hfile;
+}
+
+/**
+ * gsl_hfile_close
+ * @hfile:     valid #GslHFile
+ *
+ * Close and destroy a #GslHFile.
+ * This function is MT-safe and may be called from any thread.
+ */
+void
+gsl_hfile_close (GslHFile *hfile)
+{
+  gboolean destroy = FALSE;
+
+  g_return_if_fail (hfile != NULL);
+  g_return_if_fail (hfile->ocount > 0);
+
+  GSL_SYNC_LOCK (&fdpool_mutex);
+  GSL_SYNC_LOCK (&hfile->mutex);
+  if (hfile->ocount > 1)
+    hfile->ocount--;
+  else
+    {
+      if (!g_hash_table_remove (hfile_ht, hfile))
+	g_warning ("%s: failed to unlink hashed file (%p)",
+		   G_STRLOC, hfile);
+      else
+	{
+	  hfile->ocount = 0;
+	  destroy = TRUE;
+	}
+    }
+  GSL_SYNC_UNLOCK (&hfile->mutex);
+  GSL_SYNC_UNLOCK (&fdpool_mutex);
+
+  if (destroy)
+    {
+      gsl_mutex_destroy (&hfile->mutex);
+      close (hfile->fd);
+      g_free (hfile->file_name);
+      gsl_delete_struct (GslHFile, hfile);
+    }
+  errno = 0;
+}
+
+/**
+ * gsl_hfile_pread
+ * @hfile:   valid GslHFile
+ * @offset:  offset in bytes within 0 and file end
+ * @n_bytes: number of bytes to read
+ * @bytes:   buffer to store read bytes
+ * @error_p: pointer to GslErrorType location
+ * @RETURNS: amount of bytes read or -1 if an error occoured (errno set)
+ *
+ * Read a block of bytes from a GslHFile.
+ * This function is MT-safe and may be called from any thread.
+ */
+GslLong
+gsl_hfile_pread (GslHFile *hfile,
+		 GslLong   offset,
+		 GslLong   n_bytes,
+		 gpointer  bytes)
+{
+  GslLong ret_bytes = -1;
+  gint ret_errno;
+
+  errno = EFAULT;
+  g_return_val_if_fail (hfile != NULL, -1);
+  g_return_val_if_fail (hfile->ocount > 0, -1);
+  g_return_val_if_fail (offset >= 0, -1);
+  if (offset >= hfile->n_bytes || n_bytes < 1)
+    {
+      errno = 0;
+      return 0;
+    }
+  g_return_val_if_fail (bytes != NULL, -1);
+
+  GSL_SYNC_LOCK (&hfile->mutex);
+  if (hfile->ocount)
+    {
+      if (hfile->cpos != offset)
+	{
+	  hfile->cpos = lseek (hfile->fd, offset, SEEK_SET);
+	  if (hfile->cpos < 0 && errno != EINVAL)
+	    {
+	      ret_errno = errno;
+	      GSL_SYNC_UNLOCK (&hfile->mutex);
+	      errno = ret_errno;
+	      return -1;
+	    }
+	}
+      if (hfile->cpos == offset)
+	{
+	  do
+	    ret_bytes = read (hfile->fd, bytes, n_bytes);
+	  while (ret_bytes < 0 && errno == EINTR);
+	  if (ret_bytes < 0)
+	    {
+	      ret_errno = errno;
+	      ret_bytes = -1;
+	    }
+	  else
+	    {
+	      ret_errno = 0;
+	      hfile->cpos += ret_bytes;
+	    }
+	}
+      else	/* this should only happen if the file changed since open() */
+	{
+	  hfile->cpos = -1;
+	  if (offset + n_bytes > hfile->n_bytes)
+	    n_bytes = hfile->n_bytes - offset;
+	  memset (bytes, 0, n_bytes);
+	  ret_bytes = n_bytes;
+	  ret_errno = 0;
+	}
+    }
+  else
+    ret_errno = EFAULT;
+  GSL_SYNC_UNLOCK (&hfile->mutex);
+
+  errno = ret_errno;
+  return ret_bytes;
+}
+
+/**
+ * gsl_rfile_open
+ * @file_name: name of the file to open
+ * @RETURNS:   a new opened #GslRFile or NULL if an error occoured (errno set)
+ *
+ * Open a file for reading and create a GSL read only file handle for it.
+ * The motivation for using a #GslRFile over normal unix files
+ * is to reduce the amount of opened unix file descriptors by using
+ * a #GslHFile for the actual IO.
+ */
+GslRFile*
+gsl_rfile_open (const gchar *file_name)
+{
+  GslHFile *hfile = gsl_hfile_open (file_name);
+  GslRFile *rfile;
+
+  if (!hfile)
+    rfile = NULL;
+  else
+    {
+      rfile = gsl_new_struct0 (GslRFile, 1);
+      rfile->hfile = hfile;
+      rfile->offset = 0;
+    }
+  return rfile;
+}
+
+/**
+ * gsl_rfile_name
+ * @rfile:   valid #GslRFile
+ * @RETURNS: the file name used to open this file
+ *
+ * Retrive the file name used to open @rfile.
+ */
+gchar*
+gsl_rfile_name (GslRFile *rfile)
+{
+  errno = EFAULT;
+  g_return_val_if_fail (rfile != NULL, NULL);
+
+  errno = 0;
+  return rfile->hfile->file_name;
+}
+
+/**
+ * gsl_rfile_seek_set
+ * @rfile:   valid #GslRFile
+ * @offset:  new seek position within 0 and gsl_rfile_length()+1
+ * @RETURNS: resulting position within 0 and gsl_rfile_length()+1
+ *
+ * Set the current #GslRFile seek position.
+ */
+GslLong
+gsl_rfile_seek_set (GslRFile *rfile,
+		    GslLong   offset)
+{
+  GslLong l;
+
+  errno = EFAULT;
+  g_return_val_if_fail (rfile != NULL, 0);
+
+  l = rfile->hfile->n_bytes;
+  rfile->offset = CLAMP (offset, 0, l);
+
+  errno = 0;
+  return rfile->offset;
+}
+
+/**
+ * gsl_rfile_position
+ * @rfile:   valid #GslRFile
+ * @RETURNS: current position within 0 and gsl_rfile_length()
+ *
+ * Retrive the current #GslRFile seek position.
+ */
+GslLong
+gsl_rfile_position (GslRFile *rfile)
+{
+  errno = EFAULT;
+  g_return_val_if_fail (rfile != NULL, 0);
+
+  errno = 0;
+  return rfile->offset;
+}
+
+/**
+ * gsl_rfile_length
+ * @rfile:   valid #GslRFile
+ * @RETURNS: total length of the #GslRFile in bytes
+ *
+ * Retrive the file length of @rfile in bytes.
+ */
+GslLong
+gsl_rfile_length (GslRFile *rfile)
+{
+  GslLong l;
+
+  errno = EFAULT;
+  g_return_val_if_fail (rfile != NULL, 0);
+
+  l = rfile->hfile->n_bytes;
+
+  errno = 0;
+  return l;
+}
+
+/**
+ * gsl_rfile_pread
+ * @rfile:   valid GslRFile
+ * @offset:  offset in bytes within 0 and gsl_rfile_length()
+ * @n_bytes: number of bytes to read
+ * @bytes:   buffer to store read bytes
+ * @error_p: pointer to GslErrorType location
+ * @RETURNS: amount of bytes read or -1 if an error occoured (errno set)
+ *
+ * Read a block of bytes from a GslRFile at a specified position.
+ */
+GslLong
+gsl_rfile_pread (GslRFile *rfile,
+		 GslLong   offset,
+		 GslLong   n_bytes,
+		 gpointer  bytes)
+{
+  errno = EFAULT;
+  g_return_val_if_fail (rfile != NULL, -1);
+
+  return gsl_hfile_pread (rfile->hfile, offset, n_bytes, bytes);
+}
+
+/**
+ * gsl_rfile_read
+ * @rfile:   valid GslRFile
+ * @n_bytes: number of bytes to read
+ * @bytes:   buffer to store read bytes
+ * @error_p: pointer to GslErrorType location
+ * @RETURNS: amount of bytes read or -1 if an error occoured (errno set)
+ *
+ * Read a block of bytes from a GslRFile from the current seek position
+ * and advance the seek position.
+ */
+GslLong
+gsl_rfile_read (GslRFile *rfile,
+		GslLong   n_bytes,
+		gpointer  bytes)
+{
+  GslLong l;
+
+  errno = EFAULT;
+  g_return_val_if_fail (rfile != NULL, -1);
+
+  l = gsl_hfile_pread (rfile->hfile, rfile->offset, n_bytes, bytes);
+  if (l > 0)
+    rfile->offset += l;
+  return l;
+}
+
+/**
+ * gsl_rfile_close
+ * @rfile:     valid #GslRFile
+ *
+ * Close and destroy a #GslRFile.
+ */
+void
+gsl_rfile_close (GslRFile *rfile)
+{
+  errno = EFAULT;
+  g_return_if_fail (rfile != NULL);
+
+  gsl_hfile_close (rfile->hfile);
+  gsl_delete_struct (GslRFile, rfile);
+  errno = 0;
+}
diff --git a/flow/gsl/gslfilehash.h b/flow/gsl/gslfilehash.h
new file mode 100644
index 0000000..cc70bee
--- /dev/null
+++ b/flow/gsl/gslfilehash.h
@@ -0,0 +1,77 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2002 Tim Janik
+ *
+ * This library 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 library 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.
+ */
+#ifndef __GSL_FILE_HASH_H__
+#define __GSL_FILE_HASH_H__
+
+#include <gsl/gsldefs.h>
+#include <gsl/gslcommon.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+/* --- typedefs & structures --- */
+typedef struct {
+  gchar   *file_name;
+  GTime    mtime;
+  GslLong  n_bytes;
+  /*< private >*/
+  GslLong  cpos;
+  GslMutex mutex;
+  gint     fd;
+  guint    ocount;
+} GslHFile;
+typedef struct {
+  GslHFile *hfile;
+  GslLong   offset;
+} GslRFile;
+
+
+/* --- GslHFile API --- */
+GslHFile* gsl_hfile_open	(const gchar	*file_name);
+GslLong	  gsl_hfile_pread	(GslHFile	*hfile,
+				 GslLong	 offset,
+				 GslLong         n_bytes,
+				 gpointer	 bytes);
+void	  gsl_hfile_close	(GslHFile	*hfile);
+
+
+/* --- GslRFile API --- */
+GslRFile* gsl_rfile_open	(const gchar	*file_name);
+gchar*    gsl_rfile_name	(GslRFile	*rfile);
+GslLong	  gsl_rfile_pread	(GslRFile	*rfile,
+				 GslLong	 offset,
+				 GslLong         n_bytes,
+				 gpointer	 bytes);
+GslLong	  gsl_rfile_read	(GslRFile	*rfile,
+				 GslLong         n_bytes,
+				 gpointer	 bytes);
+GslLong	  gsl_rfile_seek_set	(GslRFile	*rfile,
+				 GslLong	 offset);
+GslLong	  gsl_rfile_position	(GslRFile	*rfile);
+GslLong	  gsl_rfile_length	(GslRFile	*rfile);
+void	  gsl_rfile_close	(GslRFile	*rfile);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_FILE_HASH_H__ */
diff --git a/flow/gsl/gslfilter.c b/flow/gsl/gslfilter.c
new file mode 100644
index 0000000..5bf8ff5
--- /dev/null
+++ b/flow/gsl/gslfilter.c
@@ -0,0 +1,1379 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Stefan Westerfeld and Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslfilter.h"
+
+#include "gslfft.h"
+#include "gslsignal.h"
+#include <string.h>
+
+
+/* --- common utilities --- */
+static inline double
+cotan (double x)
+{
+  return - tan (x + GSL_PI * 0.5);
+}
+
+static double
+gsl_db_invert (double x)
+{
+  /* db = 20*log(x)/log(10); */
+  return exp (x * log (10) / 20.0);
+}
+
+static void
+band_filter_common (unsigned int iorder,
+		    double       p_freq, /* 0..pi */
+		    double       s_freq, /* 0..pi */
+		    double       epsilon,
+		    GslComplex  *roots,
+		    GslComplex  *poles,
+		    double      *a,      /* [0..iorder] */
+		    double      *b,
+		    gboolean     band_pass,
+		    gboolean     t1_norm)
+{
+  unsigned int iorder2 = iorder >> 1;
+  GslComplex *poly = g_newa (GslComplex, iorder + 1);
+  GslComplex fpoly[2 + 1] = { { 0, }, { 0, }, { 1, 0 } };
+  double alpha, norm;
+  guint i;
+
+  epsilon = gsl_trans_zepsilon2ss (epsilon);
+  alpha = cos ((s_freq + p_freq) * 0.5) / cos ((s_freq - p_freq) * 0.5);
+
+  fpoly[0] = gsl_complex (1, 0);
+  fpoly[1] = gsl_complex (1, 0);
+  for (i = 0; i < iorder2; i++)
+    {
+      fpoly[0] = gsl_complex_mul (fpoly[0], gsl_complex_sub (gsl_complex (1, 0), gsl_complex_reciprocal (roots[i])));
+      fpoly[1] = gsl_complex_mul (fpoly[1], gsl_complex_sub (gsl_complex (1, 0), gsl_complex_reciprocal (poles[i])));
+    }
+  norm = gsl_complex_div (fpoly[1], fpoly[0]).re;
+
+  if ((iorder2 & 1) == 0)      /* norm is fluctuation minimum */
+    norm *= sqrt (1.0 / (1.0 + epsilon * epsilon));
+
+  /* z nominator polynomial */
+  poly[0] = gsl_complex (norm, 0);
+  for (i = 0; i < iorder2; i++)
+    {
+      GslComplex t, alphac = gsl_complex (alpha, 0);
+
+      t = band_pass ? gsl_complex_inv (roots[i]) : roots[i];
+      fpoly[1] = gsl_complex_sub (gsl_complex_div (alphac, t), alphac);
+      fpoly[0] = gsl_complex_inv (gsl_complex_reciprocal (t));
+      gsl_cpoly_mul (poly, i * 2, poly, 2, fpoly);
+    }
+  for (i = 0; i <= iorder; i++)
+    a[i] = poly[i].re;
+
+  /* z denominator polynomial */
+  poly[0] = gsl_complex (1, 0);
+  for (i = 0; i < iorder2; i++)
+    {
+      GslComplex t, alphac = gsl_complex (alpha, 0);
+
+      t = band_pass ? gsl_complex_inv (poles[i]) : poles[i];
+      fpoly[1] = gsl_complex_sub (gsl_complex_div (alphac, t), alphac);
+      fpoly[0] = gsl_complex_inv (gsl_complex_reciprocal (t));
+      gsl_cpoly_mul (poly, i * 2, poly, 2, fpoly);
+    }
+  for (i = 0; i <= iorder; i++)
+    b[i] = poly[i].re;
+  gsl_poly_scale (iorder, a, 1.0 / b[0]);
+  gsl_poly_scale (iorder, b, 1.0 / b[0]);
+}
+
+static void
+filter_rp_to_z (unsigned int iorder,
+		GslComplex  *roots, /* [0..iorder-1] */
+		GslComplex  *poles,
+		double      *a,     /* [0..iorder] */
+		double      *b)
+{
+  GslComplex *poly = g_newa (GslComplex, iorder + 1);
+  guint i;
+
+  /* z nominator polynomial */
+  poly[0] = gsl_complex (1, 0);
+  for (i = 0; i < iorder; i++)
+    gsl_cpoly_mul_reciprocal (i + 1, poly, roots[i]);
+  for (i = 0; i <= iorder; i++)
+    a[i] = poly[i].re;
+
+  /* z denominator polynomial */
+  poly[0] = gsl_complex (1, 0);
+  for (i = 0; i < iorder; i++)
+    gsl_cpoly_mul_reciprocal (i + 1, poly, poles[i]);
+  for (i = 0; i <= iorder; i++)
+    b[i] = poly[i].re;
+}
+
+static void
+filter_lp_invert (unsigned int iorder,
+		  double      *a,     /* [0..iorder] */
+		  double      *b)
+{
+  guint i;
+
+  for (i = 1; i <= iorder; i +=2)
+    {
+      a[i] = -a[i];
+      b[i] = -b[i];
+    }
+}
+
+
+/* --- butterworth filter --- */
+void
+gsl_filter_butter_rp (unsigned int iorder,
+		      double       freq, /* 0..pi */
+		      double       epsilon,
+		      GslComplex  *roots,    /* [0..iorder-1] */
+		      GslComplex  *poles)
+{
+  double pi = GSL_PI, order = iorder;
+  double beta_mul = pi / (2.0 * order);
+  /* double kappa = gsl_trans_freq2s (freq); */
+  double kappa;
+  GslComplex root;
+  unsigned int i;
+
+  epsilon = gsl_trans_zepsilon2ss (epsilon);
+  kappa = gsl_trans_freq2s (freq) * pow (epsilon, -1.0 / order);
+
+  /* construct poles for butterworth filter */
+  for (i = 1; i <= iorder; i++)
+    {
+      double t = (i << 1) + iorder - 1;
+      double beta = t * beta_mul;
+
+      root.re = kappa * cos (beta);
+      root.im = kappa * sin (beta);
+      poles[i - 1] = gsl_trans_s2z (root);
+    }
+
+  /* z nominator polynomial */
+  for (i = 0; i < iorder; i++)
+    roots[i] = gsl_complex (-1, 0);
+}
+
+
+/* --- tschebyscheff type 1 filter --- */
+static double
+tschebyscheff_eval (unsigned int degree,
+		    double       x)
+{
+  double td = x, td_m_1 = 1;
+  unsigned int d = 1;
+
+  /* eval polynomial for a certain x */
+  if (degree == 0)
+    return 1;
+
+  while (d < degree)
+    {
+      double td1 = 2 * x * td - td_m_1;
+
+      td_m_1 = td;
+      td = td1;
+      d++;
+    }
+  return td;
+}
+
+static double
+tschebyscheff_inverse (unsigned int degree,
+		       double       x)
+{
+  /* note, that thebyscheff_eval(degree,x)=cosh(degree*acosh(x)) */
+  return cosh (acosh (x) / degree);
+}
+
+void
+gsl_filter_tscheb1_rp (unsigned int iorder,
+		       double       freq,  /* 1..pi */
+		       double       epsilon,
+		       GslComplex  *roots, /* [0..iorder-1] */
+		       GslComplex  *poles)
+{
+  double pi = GSL_PI, order = iorder;
+  double alpha;
+  double beta_mul = pi / (2.0 * order);
+  double kappa = gsl_trans_freq2s (freq);
+  GslComplex root;
+  unsigned int i;
+
+  epsilon = gsl_trans_zepsilon2ss (epsilon);
+  alpha = asinh (1.0 / epsilon) / order;
+
+  /* construct poles polynomial from tschebyscheff polynomial */
+  for (i = 1; i <= iorder; i++)
+    {
+      double t = (i << 1) + iorder - 1;
+      double beta = t * beta_mul;
+
+      root.re = kappa * sinh (alpha) * cos (beta);
+      root.im = kappa * cosh (alpha) * sin (beta);
+      poles[i - 1] = gsl_trans_s2z (root);
+    }
+
+  /* z nominator polynomial */
+  for (i = 0; i < iorder; i++)
+    roots[i] = gsl_complex (-1, 0);
+}
+
+
+/* --- tschebyscheff type 2 filter --- */
+void
+gsl_filter_tscheb2_rp (unsigned int iorder,
+		       double       c_freq, /* 1..pi */
+		       double       steepness,
+		       double       epsilon,
+		       GslComplex  *roots,  /* [0..iorder-1] */
+		       GslComplex  *poles)
+{
+  double pi = GSL_PI, order = iorder;
+  double r_freq = c_freq * steepness;
+  double kappa_c = gsl_trans_freq2s (c_freq);
+  double kappa_r = gsl_trans_freq2s (r_freq);
+  double tepsilon;
+  double alpha;
+  double beta_mul = pi / (2.0 * order);
+  GslComplex root;
+  unsigned int i;
+
+#if 0
+  /* triggers an internal compiler error with gcc-2.95.4 (and certain
+   * combinations of optimization options)
+   */
+  g_return_if_fail (c_freq * steepness < GSL_PI);
+#endif
+  g_return_if_fail (steepness > 1.0);
+
+  epsilon = gsl_trans_zepsilon2ss (epsilon);
+  tepsilon = epsilon * tschebyscheff_eval (iorder, kappa_r / kappa_c);
+  alpha = asinh (tepsilon) / order;
+
+  /* construct poles polynomial from tschebyscheff polynomial */
+  for (i = 1; i <= iorder; i++)
+    {
+      double t = (i << 1) + iorder - 1;
+      double beta = t * beta_mul;
+
+      root.re = sinh (alpha) * cos (beta);
+      root.im = cosh (alpha) * sin (beta);
+      root = gsl_complex_div (gsl_complex (kappa_r, 0), root);
+      root = gsl_trans_s2z (root);
+      poles[i - 1] = root;
+    }
+
+  /* construct roots polynomial from tschebyscheff polynomial */
+  for (i = 1; i <= iorder; i++)
+    {
+      double t = (i << 1) - 1;
+      GslComplex root = gsl_complex (0, cos (t * beta_mul));
+
+      if (fabs (root.im) > 1e-14)
+	{
+	  root = gsl_complex_div (gsl_complex (kappa_r, 0), root);
+	  root = gsl_trans_s2z (root);
+	}
+      else
+	root = gsl_complex (-1, 0);
+      roots[i - 1] = root;
+    }
+}
+
+/**
+ * gsl_filter_tscheb2_steepness_db
+ * @iorder:      filter order
+ * @c_freq:      passband cutoff frequency (0..pi)
+ * @epsilon:     fall off at passband frequency (0..1)
+ * @stopband_db: reduction in stopband in dB (>= 0)
+ * Calculates the steepness parameter for Tschebyscheff type 2 lowpass filter,
+ * based on the ripple residue in the stop band.
+ */
+double
+gsl_filter_tscheb2_steepness_db (unsigned int iorder,
+				 double       c_freq,
+				 double       epsilon,
+				 double       stopband_db)
+{
+  return gsl_filter_tscheb2_steepness (iorder, c_freq, epsilon, gsl_db_invert (-stopband_db));
+}
+
+/**
+ * gsl_filter_tscheb2_steepness
+ * @iorder:    filter order
+ * @c_freq:    passband cutoff frequency (0..pi)
+ * @epsilon:   fall off at passband frequency (0..1)
+ * @residue:   maximum of transfer function in stopband (0..1)
+ * Calculates the steepness parameter for Tschebyscheff type 2 lowpass filter,
+ * based on ripple residue in the stop band.
+ */
+double
+gsl_filter_tscheb2_steepness (unsigned int iorder,
+			      double       c_freq,
+			      double       epsilon,
+			      double       residue)
+{
+  double kappa_c, kappa_r, r_freq;
+
+  epsilon = gsl_trans_zepsilon2ss (epsilon);
+  kappa_c = gsl_trans_freq2s (c_freq);
+  kappa_r = tschebyscheff_inverse (iorder, sqrt (1.0 / (residue * residue) - 1.0) / epsilon) * kappa_c;
+  r_freq = gsl_trans_freq2z (kappa_r);
+
+  return r_freq / c_freq;
+}
+
+
+/* --- lowpass filters --- */
+/**
+ * gsl_filter_butter_lp
+ * @iorder:   filter order
+ * @freq:     cutoff frequency (0..pi)
+ * @epsilon:  fall off at cutoff frequency (0..1)
+ * @a:        root polynomial coefficients a[0..iorder]
+ * @b:        pole polynomial coefficients b[0..iorder]
+ * Butterworth lowpass filter.
+ */
+void
+gsl_filter_butter_lp (unsigned int iorder,
+		      double       freq, /* 0..pi */
+		      double       epsilon,
+		      double      *a,    /* [0..iorder] */
+		      double      *b)
+{
+  GslComplex *roots = g_newa (GslComplex, iorder);
+  GslComplex *poles = g_newa (GslComplex, iorder);
+  double norm;
+
+  g_return_if_fail (freq > 0 && freq < GSL_PI);
+
+  gsl_filter_butter_rp (iorder, freq, epsilon, roots, poles);
+  filter_rp_to_z (iorder, roots, poles, a, b);
+
+  /* scale maximum to 1.0 */
+  norm = gsl_poly_eval (iorder, b, 1) / gsl_poly_eval (iorder, a, 1);
+  gsl_poly_scale (iorder, a, norm);
+}
+
+/**
+ * gsl_filter_tscheb1_lp
+ * @iorder:   filter order
+ * @freq:     cutoff frequency (0..pi)
+ * @epsilon:  fall off at cutoff frequency (0..1)
+ * @a:        root polynomial coefficients a[0..iorder]
+ * @b:        pole polynomial coefficients b[0..iorder]
+ * Tschebyscheff type 1 lowpass filter.
+ */
+void
+gsl_filter_tscheb1_lp (unsigned int iorder,
+		       double       freq, /* 0..pi */
+		       double       epsilon,
+		       double      *a,    /* [0..iorder] */
+		       double      *b)
+{
+  GslComplex *roots = g_newa (GslComplex, iorder);
+  GslComplex *poles = g_newa (GslComplex, iorder);
+  double norm;
+
+  g_return_if_fail (freq > 0 && freq < GSL_PI);
+
+  gsl_filter_tscheb1_rp (iorder, freq, epsilon, roots, poles);
+  filter_rp_to_z (iorder, roots, poles, a, b);
+
+  /* scale maximum to 1.0 */
+  norm = gsl_poly_eval (iorder, b, 1) / gsl_poly_eval (iorder, a, 1);
+  if ((iorder & 1) == 0)      /* norm is fluctuation minimum */
+    {
+      epsilon = gsl_trans_zepsilon2ss (epsilon);
+      norm *= sqrt (1.0 / (1.0 + epsilon * epsilon));
+    }
+  gsl_poly_scale (iorder, a, norm);
+}
+
+/**
+ * gsl_filter_tscheb2_lp
+ * @iorder:    filter order
+ * @freq:      passband cutoff frequency (0..pi)
+ * @steepness: frequency steepness (c_freq * steepness < pi)
+ * @epsilon:   fall off at passband frequency (0..1)
+ * @a:         root polynomial coefficients a[0..iorder]
+ * @b:         pole polynomial coefficients b[0..iorder]
+ * Tschebyscheff type 2 lowpass filter.
+ * To gain a transition band between freq1 and freq2, pass arguements
+ * @freq=freq1 and @steepness=freq2/freq1. To specify the transition
+ * band width in fractions of octaves, pass @steepness=2^octave_fraction.
+ */
+void
+gsl_filter_tscheb2_lp (unsigned int iorder,
+		       double       freq,   /* 0..pi */
+		       double       steepness,
+		       double       epsilon,
+		       double      *a,      /* [0..iorder] */
+		       double      *b)
+{
+  GslComplex *roots = g_newa (GslComplex, iorder);
+  GslComplex *poles = g_newa (GslComplex, iorder);
+  double norm;
+
+  g_return_if_fail (freq > 0 && freq < GSL_PI);
+  g_return_if_fail (freq * steepness < GSL_PI);
+  g_return_if_fail (steepness > 1.0);
+
+  gsl_filter_tscheb2_rp (iorder, freq, steepness, epsilon, roots, poles);
+  filter_rp_to_z (iorder, roots, poles, a, b);
+
+  /* scale maximum to 1.0 */
+  norm = gsl_poly_eval (iorder, b, 1) / gsl_poly_eval (iorder, a, 1); /* H(z=0):=1, e^(j*omega) for omega=0 => e^0==1 */
+  gsl_poly_scale (iorder, a, norm);
+}
+
+
+/* --- highpass filters --- */
+/**
+ * gsl_filter_butter_hp
+ * @iorder:   filter order
+ * @freq:     passband frequency (0..pi)
+ * @epsilon:  fall off at passband frequency (0..1)
+ * @a:        root polynomial coefficients a[0..iorder]
+ * @b:        pole polynomial coefficients b[0..iorder]
+ * Butterworth highpass filter.
+ */
+void
+gsl_filter_butter_hp (unsigned int iorder,
+		      double       freq, /* 0..pi */
+		      double       epsilon,
+		      double      *a,    /* [0..iorder] */
+		      double      *b)
+{
+  g_return_if_fail (freq > 0 && freq < GSL_PI);
+
+  freq = GSL_PI - freq;
+  gsl_filter_butter_lp (iorder, freq, epsilon, a, b);
+  filter_lp_invert (iorder, a, b);
+}
+
+/**
+ * gsl_filter_tscheb1_hp
+ * @iorder:   filter order
+ * @freq:     passband frequency (0..pi)
+ * @epsilon:  fall off at passband frequency (0..1)
+ * @a:        root polynomial coefficients a[0..iorder]
+ * @b:        pole polynomial coefficients b[0..iorder]
+ * Tschebyscheff type 1 highpass filter.
+ */
+void
+gsl_filter_tscheb1_hp (unsigned int iorder,
+		       double       freq, /* 0..pi */
+		       double       epsilon,
+		       double      *a,    /* [0..iorder] */
+		       double      *b)
+{
+  g_return_if_fail (freq > 0 && freq < GSL_PI);
+
+  freq = GSL_PI - freq;
+  gsl_filter_tscheb1_lp (iorder, freq, epsilon, a, b);
+  filter_lp_invert (iorder, a, b);
+}
+
+/**
+ * gsl_filter_tscheb2_hp
+ * @iorder:    filter order
+ * @freq:      stopband frequency (0..pi)
+ * @steepness: frequency steepness
+ * @epsilon:   fall off at passband frequency (0..1)
+ * @a:         root polynomial coefficients a[0..iorder]
+ * @b:         pole polynomial coefficients b[0..iorder]
+ * Tschebyscheff type 2 highpass filter.
+ */
+void
+gsl_filter_tscheb2_hp   (unsigned int iorder,
+			 double       freq,
+			 double       steepness,
+			 double       epsilon,
+			 double      *a,      /* [0..iorder] */
+			 double      *b)
+{
+  g_return_if_fail (freq > 0 && freq < GSL_PI);
+
+  freq = GSL_PI - freq;
+  gsl_filter_tscheb2_lp (iorder, freq, steepness, epsilon, a, b);
+  filter_lp_invert (iorder, a, b);
+}
+
+
+/* --- bandpass filters --- */
+/**
+ * gsl_filter_butter_bp
+ * @iorder:   filter order (must be even)
+ * @freq1:    stopband end frequency (0..pi)
+ * @freq2:    passband end frequency (0..pi)
+ * @epsilon:  fall off at passband frequency (0..1)
+ * @a:        root polynomial coefficients a[0..iorder]
+ * @b:        pole polynomial coefficients b[0..iorder]
+ * Butterworth bandpass filter.
+ */
+void
+gsl_filter_butter_bp (unsigned int iorder,
+		      double       freq1, /* 0..pi */
+		      double       freq2, /* 0..pi */
+		      double       epsilon,
+		      double      *a,      /* [0..iorder] */
+		      double      *b)
+{
+  unsigned int iorder2 = iorder >> 1;
+  GslComplex *roots = g_newa (GslComplex, iorder2);
+  GslComplex *poles = g_newa (GslComplex, iorder2);
+  double theta;
+
+  g_return_if_fail ((iorder & 0x01) == 0);
+  g_return_if_fail (freq1 > 0);
+  g_return_if_fail (freq1 < freq2);
+  g_return_if_fail (freq2 < GSL_PI);
+
+  theta = 2. * atan2 (1., cotan ((freq2 - freq1) * 0.5));
+
+  gsl_filter_butter_rp (iorder2, theta, epsilon, roots, poles);
+  band_filter_common (iorder, freq1, freq2, epsilon, roots, poles, a, b, TRUE, FALSE);
+}
+
+/**
+ * gsl_filter_tscheb1_bp
+ * @iorder:   filter order (must be even)
+ * @freq1:    stopband end frequency (0..pi)
+ * @freq2:    passband end frequency (0..pi)
+ * @epsilon:  fall off at passband frequency (0..1)
+ * @a:        root polynomial coefficients a[0..iorder]
+ * @b:        pole polynomial coefficients b[0..iorder]
+ * Tschebyscheff type 1 bandpass filter.
+ */
+void
+gsl_filter_tscheb1_bp (unsigned int iorder,
+		       double       freq1, /* 0..pi */
+		       double       freq2, /* 0..pi */
+		       double       epsilon,
+		       double      *a,      /* [0..iorder] */
+		       double      *b)
+{
+  unsigned int iorder2 = iorder >> 1;
+  GslComplex *roots = g_newa (GslComplex, iorder2);
+  GslComplex *poles = g_newa (GslComplex, iorder2);
+  double theta;
+
+  g_return_if_fail ((iorder & 0x01) == 0);
+  g_return_if_fail (freq1 > 0);
+  g_return_if_fail (freq1 < freq2);
+  g_return_if_fail (freq2 < GSL_PI);
+
+  theta = 2. * atan2 (1., cotan ((freq2 - freq1) * 0.5));
+
+  gsl_filter_tscheb1_rp (iorder2, theta, epsilon, roots, poles);
+  band_filter_common (iorder, freq1, freq2, epsilon, roots, poles, a, b, TRUE, TRUE);
+}
+
+/**
+ * gsl_filter_tscheb2_bp
+ * @iorder:    filter order (must be even)
+ * @freq1:     stopband end frequency (0..pi)
+ * @freq2:     passband end frequency (0..pi)
+ * @steepness: frequency steepness factor
+ * @epsilon:   fall off at passband frequency (0..1)
+ * @a:         root polynomial coefficients a[0..iorder]
+ * @b:         pole polynomial coefficients b[0..iorder]
+ * Tschebyscheff type 2 bandpass filter.
+ */
+void
+gsl_filter_tscheb2_bp (unsigned int iorder,
+		       double       freq1, /* 0..pi */
+		       double       freq2, /* 0..pi */
+		       double       steepness,
+		       double       epsilon,
+		       double      *a,      /* [0..iorder] */
+		       double      *b)
+{
+  unsigned int iorder2 = iorder >> 1;
+  GslComplex *roots = g_newa (GslComplex, iorder2);
+  GslComplex *poles = g_newa (GslComplex, iorder2);
+  double theta;
+
+  g_return_if_fail ((iorder & 0x01) == 0);
+  g_return_if_fail (freq1 > 0);
+  g_return_if_fail (freq1 < freq2);
+  g_return_if_fail (freq2 < GSL_PI);
+
+  theta = 2. * atan2 (1., cotan ((freq2 - freq1) * 0.5));
+
+  gsl_filter_tscheb2_rp (iorder2, theta, steepness, epsilon, roots, poles);
+  band_filter_common (iorder, freq1, freq2, epsilon, roots, poles, a, b, TRUE, FALSE);
+}
+
+
+/* --- bandstop filters --- */
+/**
+ * gsl_filter_butter_bs
+ * @iorder:   filter order (must be even)
+ * @freq1:    passband end frequency (0..pi)
+ * @freq2:    stopband end frequency (0..pi)
+ * @epsilon:  fall off at passband frequency (0..1)
+ * @a:        root polynomial coefficients a[0..iorder]
+ * @b:        pole polynomial coefficients b[0..iorder]
+ * Butterworth bandstop filter.
+ */
+void
+gsl_filter_butter_bs (unsigned int iorder,
+		      double       freq1, /* 0..pi */
+		      double       freq2, /* 0..pi */
+		      double       epsilon,
+		      double      *a,      /* [0..iorder] */
+		      double      *b)
+{
+  unsigned int iorder2 = iorder >> 1;
+  GslComplex *roots = g_newa (GslComplex, iorder2);
+  GslComplex *poles = g_newa (GslComplex, iorder2);
+  double theta;
+
+  g_return_if_fail ((iorder & 0x01) == 0);
+  g_return_if_fail (freq1 > 0);
+  g_return_if_fail (freq1 < freq2);
+  g_return_if_fail (freq2 < GSL_PI);
+
+  theta = 2. * atan2 (1., tan ((freq2 - freq1) * 0.5));
+
+  gsl_filter_butter_rp (iorder2, theta, epsilon, roots, poles);
+  band_filter_common (iorder, freq1, freq2, epsilon, roots, poles, a, b, FALSE, FALSE);
+}
+
+/**
+ * gsl_filter_tscheb1_bs
+ * @iorder:   filter order (must be even)
+ * @freq1:    passband end frequency (0..pi)
+ * @freq2:    stopband end frequency (0..pi)
+ * @epsilon:  fall off at passband frequency (0..1)
+ * @a:        root polynomial coefficients a[0..iorder]
+ * @b:        pole polynomial coefficients b[0..iorder]
+ * Tschebyscheff type 1 bandstop filter.
+ */
+void
+gsl_filter_tscheb1_bs (unsigned int iorder,
+		       double       freq1, /* 0..pi */
+		       double       freq2, /* 0..pi */
+		       double       epsilon,
+		       double      *a,      /* [0..iorder] */
+		       double      *b)
+{
+  unsigned int iorder2 = iorder >> 1;
+  GslComplex *roots = g_newa (GslComplex, iorder2);
+  GslComplex *poles = g_newa (GslComplex, iorder2);
+  double theta;
+
+  g_return_if_fail ((iorder & 0x01) == 0);
+  g_return_if_fail (freq1 > 0);
+  g_return_if_fail (freq1 < freq2);
+  g_return_if_fail (freq2 < GSL_PI);
+
+  theta = 2. * atan2 (1., tan ((freq2 - freq1) * 0.5));
+
+  gsl_filter_tscheb1_rp (iorder2, theta, epsilon, roots, poles);
+  band_filter_common (iorder, freq1, freq2, epsilon, roots, poles, a, b, FALSE, TRUE);
+}
+
+/**
+ * gsl_filter_tscheb2_bs
+ * @iorder:    filter order (must be even)
+ * @freq1:     passband end frequency (0..pi)
+ * @freq2:     stopband end frequency (0..pi)
+ * @steepness: frequency steepness factor
+ * @epsilon:   fall off at passband frequency (0..1)
+ * @a:         root polynomial coefficients a[0..iorder]
+ * @b:         pole polynomial coefficients b[0..iorder]
+ * Tschebyscheff type 2 bandstop filter.
+ */
+void
+gsl_filter_tscheb2_bs (unsigned int iorder,
+		       double       freq1, /* 0..pi */
+		       double       freq2, /* 0..pi */
+		       double       steepness,
+		       double       epsilon,
+		       double      *a,      /* [0..iorder] */
+		       double      *b)
+{
+  unsigned int iorder2 = iorder >> 1;
+  GslComplex *roots = g_newa (GslComplex, iorder2);
+  GslComplex *poles = g_newa (GslComplex, iorder2);
+  double theta;
+
+  g_return_if_fail ((iorder & 0x01) == 0);
+  g_return_if_fail (freq1 > 0);
+  g_return_if_fail (freq1 < freq2);
+  g_return_if_fail (freq2 < GSL_PI);
+
+  theta = 2. * atan2 (1., tan ((freq2 - freq1) * 0.5));
+
+  gsl_filter_tscheb2_rp (iorder2, theta, steepness, epsilon, roots, poles);
+  band_filter_common (iorder, freq1, freq2, epsilon, roots, poles, a, b, FALSE, FALSE);
+}
+
+
+/* --- tschebyscheff type 1 via generic root-finding --- */
+#if 0
+static void
+tschebyscheff_poly (unsigned int degree,
+		    double      *v)
+{
+  /* construct all polynomial koefficients */
+  if (degree == 0)
+    v[0] = 1;
+  else if (degree == 1)
+    {
+      v[1] = 1; v[0] = 0;
+    }
+  else
+    {
+      double *u = g_newa (double, 1 + degree);
+
+      u[degree] = 0; u[degree - 1] = 0;
+      tschebyscheff_poly (degree - 2, u);
+
+      v[0] = 0;
+      tschebyscheff_poly (degree - 1, v + 1);
+      gsl_poly_scale (degree - 1, v + 1, 2);
+
+      gsl_poly_sub (degree, v, u);
+    }
+}
+
+static void
+gsl_filter_tscheb1_test	(unsigned int iorder,
+			 double       zomega,
+			 double       epsilon,
+			 double      *a,    /* [0..iorder] */
+			 double      *b)
+{
+  GslComplex *roots = g_newa (GslComplex, iorder * 2), *r;
+  GslComplex *zf = g_newa (GslComplex, 1 + iorder);
+  double *vk = g_newa (double, 1 + iorder), norm;
+  double *q = g_newa (double, 2 * (1 + iorder));
+  double O = gsl_trans_freq2s (zomega);
+  unsigned int i;
+
+  /* calc Vk() */
+  tschebyscheff_poly (iorder, vk);
+
+  /* calc q=1+e^2*Vk()^2 */
+  gsl_poly_mul (q, iorder >> 1, vk, iorder >> 1, vk);
+  iorder *= 2;
+  gsl_poly_scale (iorder, q, epsilon * epsilon);
+  q[0] += 1;
+
+  /* find roots, fix roots by 1/(jO) */
+  gsl_poly_complex_roots (iorder, q, roots);
+  for (i = 0; i < iorder; i++)
+    roots[i] = gsl_complex_mul (roots[i], gsl_complex (0, O));
+
+  /* choose roots from the left half-plane */
+  if (0)
+    g_print ("zhqr-root:\n%s\n", gsl_complex_list (iorder, roots, "  "));
+  r = roots;
+  for (i = 0; i < iorder; i++)
+    if (roots[i].re < 0)
+      {
+	r->re = roots[i].re;
+	r->im = roots[i].im;
+	r++;
+      }
+  iorder /= 2;
+
+  /* assert roots found */
+  if (!(r - roots == iorder))
+    {
+      g_print ("ERROR: n_roots=%u != iorder=%u\n", r - roots, iorder);
+      abort ();
+    }
+
+  /* s => z */
+  for (i = 0; i < iorder; i++)
+    roots[i] = gsl_trans_s2z (roots[i]);
+
+  /* z denominator polynomial */
+  gsl_cpoly_from_roots (iorder, zf, roots);
+  for (i = 0; i <= iorder; i++)
+    b[i] = zf[i].re;
+
+  /* z nominator polynomial */
+  for (i = 0; i < iorder; i++)
+    {
+      roots[i].re = -1;
+      roots[i].im = 0;
+    }
+  gsl_cpoly_from_roots (iorder, zf, roots);
+  for (i = 0; i <= iorder; i++)
+    a[i] = zf[i].re;
+
+  /* scale for b[0]==1.0 */
+  gsl_poly_scale (iorder, b, 1.0 / b[0]);
+
+  /* scale maximum to 1.0 */
+  norm = gsl_poly_eval (iorder, a, 1) / gsl_poly_eval (iorder, b, 1);
+  if ((iorder & 0x01) == 0)	/* norm is fluctuation minimum */
+    norm /= sqrt (1.0 / (1.0 + epsilon * epsilon));
+  gsl_poly_scale (iorder, a, 1.0 / norm);
+}
+#endif
+
+
+/* --- windowed fir approximation --- */
+/* returns a blackman window: x is supposed to be in the interval [0..1] */
+static inline double
+gsl_blackman_window (double x)
+{
+  if (x < 0)
+    return 0;
+  if (x > 1)
+    return 0;
+  return 0.42 - 0.5 * cos (GSL_PI * x * 2) + 0.08 * cos (4 * GSL_PI * x);
+}
+
+/**
+ * gsl_filter_fir_approx
+ *
+ * @iorder: order of the filter (must be oven, >= 2)
+ * @freq:   the frequencies of the transfer function
+ * @value:  the desired value of the transfer function
+ *
+ * Approximates a given transfer function with an iorder-coefficient FIR filter.
+ * It is recommended to provide enough frequency values, so that
+ * @n_points >= @iorder.
+ */
+void
+gsl_filter_fir_approx (unsigned int  iorder,
+		       double       *a,	/* [0..iorder] */
+		       unsigned int  n_points,
+		       const double *freq,
+		       const double *value)
+{
+  /* TODO:
+   *
+   * a) does fft_size matter for the quality of the approximation? i.e. do
+   *    larger fft_sizes produce better filters?
+   * b) generalize windowing
+   */
+  unsigned int fft_size = 8;
+  unsigned int point = 0, i;
+  double lfreq = -2, lval = 1.0, rfreq = -1, rval = 1.0;
+  double *fft_in, *fft_out;
+  double ffact;
+
+  g_return_if_fail (iorder >= 2);
+  g_return_if_fail ((iorder & 1) == 0);
+
+  while (fft_size / 2 <= iorder)
+    fft_size *= 2;
+
+  fft_in = g_newa (double, fft_size*2);
+  fft_out = fft_in+fft_size;
+  ffact = 2.0 * GSL_PI / (double)fft_size;
+
+  for (i = 0; i <= fft_size / 2; i++)
+    {
+      double f = (double) i * ffact;
+      double pos, val;
+
+      while (f > rfreq && point != n_points)
+	{
+	  lfreq = rfreq;
+	  rfreq = freq[point];
+	  lval = rval;
+	  rval = value[point];
+	  point++;
+	}
+
+      pos = (f - lfreq) / (rfreq - lfreq);
+      val = lval * (1.0 - pos) + rval * pos;
+
+      if (i != fft_size / 2)
+	{
+	  fft_in[2 * i] = val;
+	  fft_in[2 * i + 1] = 0.0;
+	}
+      else
+	fft_in[1] = val;
+    }
+
+  gsl_power2_fftsr (fft_size, fft_in, fft_out);
+
+  for (i = 0; i <= iorder / 2; i++)
+    {
+      double c = fft_out[i] * gsl_blackman_window (0.5 + (double) i / (iorder + 2.0));
+      a[iorder / 2 - i] = c;
+      a[iorder / 2 + i] = c;
+    }
+}
+
+
+/* --- filter evaluation --- */
+void
+gsl_iir_filter_setup (GslIIRFilter  *f,
+		      guint          order,
+		      const gdouble *a,
+		      const gdouble *b,
+		      gdouble       *buffer) /* 4*(order+1) */
+{
+  guint i;
+
+  g_return_if_fail (f != NULL && a != NULL && b != NULL && buffer != NULL);
+  g_return_if_fail (order > 0);
+
+  f->order = order;
+  f->a = buffer;
+  f->b = f->a + order + 1;
+  f->w = f->b + order + 1;
+
+  memcpy (f->a, a, sizeof (a[0]) * (order + 1));
+  for (i = 0; i <= order; i++)
+    f->b[i] = -b[i];
+  memset (f->w, 0, sizeof (f->w[0]) * (order + 1) * 2);
+
+  g_return_if_fail (fabs (b[0] - 1.0) < 1e-14);
+}
+
+void
+gsl_iir_filter_change (GslIIRFilter  *f,
+		       guint          order,
+		       const gdouble *a,
+		       const gdouble *b,
+		       gdouble       *buffer)
+{
+  guint i;
+
+  g_return_if_fail (f != NULL && a != NULL && b != NULL && buffer != NULL);
+  g_return_if_fail (order > 0);
+
+  /* there's no point in calling this function if f wasn't setup properly
+   * and it's only the As and Bs that changed
+   */
+  g_return_if_fail (f->a == buffer && f->b == f->a + f->order + 1 && f->w == f->b + f->order + 1);
+
+  /* if the order changed there's no chance preserving state */
+  if (f->order != order)
+    {
+      gsl_iir_filter_setup (f, order, a, b, buffer);
+      return;
+    }
+
+  memcpy (f->a, a, sizeof (a[0]) * (order + 1));
+  for (i = 0; i <= order; i++)
+    f->b[i] = -b[i];
+  /* leaving f->w to preserve state */
+
+  g_return_if_fail (fabs (b[0] - 1.0) < 1e-14);
+}
+
+static inline gdouble /* Y */
+filter_step_direct_canon_2 (GslIIRFilter *f,
+			    gdouble       X)
+{
+  register guint n = f->order;
+  gdouble *a = f->a, *b = f->b, *w = f->w;
+  gdouble x, y, v;
+
+  v = w[n];
+  x = b[n] * v;
+  y = a[n] * v;
+
+  while (--n)
+    {
+      gdouble t1, t2;
+
+      v = w[n];
+      t1 = v * b[n];
+      t2 = v * a[n];
+      w[n+1] = v;
+      x += t1;
+      y += t2;
+    }
+
+  x += X;
+  w[1] = x;
+  y += x * a[0];
+  /* w[0] unused */
+
+  return y;
+}
+
+static inline gdouble /* Y */
+filter_step_direct_canon_1 (GslIIRFilter *f,
+			    gdouble       X)
+{
+  register guint n = f->order;
+  gdouble *a = f->a, *b = f->b, *w = f->w;
+  gdouble y, v;
+
+  /* w[n] unused */
+  y = X * a[0] + w[0];
+  v = X * a[n] + y * b[n];
+
+  while (--n)
+    {
+      gdouble t = w[n];
+
+      w[n] = v;
+      t += X * a[n];
+      v = y * b[n];
+      v += t;
+    }
+  w[0] = v;
+
+  return y;
+}
+
+#define	filter_step	filter_step_direct_canon_1
+
+void
+gsl_iir_filter_eval (GslIIRFilter *f,
+		     guint         n_values,
+		     const gfloat *x,
+		     gfloat       *y)
+{
+  const gfloat *bound;
+
+  g_return_if_fail (f != NULL && x != NULL && y != NULL);
+  g_return_if_fail (f->order > 0);
+
+  bound = x + n_values;
+  while (x < bound)
+    {
+      *y = filter_step (f, *x);
+      x++;
+      y++;
+    }
+}
+
+
+/* --- biquad filters --- */
+void
+gsl_biquad_config_init (GslBiquadConfig   *c,
+			GslBiquadType      type,
+			GslBiquadNormalize normalize)
+{
+  g_return_if_fail (c != NULL);
+
+  memset (c, 0, sizeof (*c));
+  c->type = type;
+  c->normalize = normalize;
+  gsl_biquad_config_setup (c, 0.5, 3, 1);
+  c->approx_values = TRUE;	/* need _setup() */
+}
+
+void
+gsl_biquad_config_setup (GslBiquadConfig *c,
+			 gfloat           f_fn,
+			 gfloat           gain,
+			 gfloat           quality)
+{
+  g_return_if_fail (c != NULL);
+  g_return_if_fail (f_fn >= 0 && f_fn <= 1);
+
+  if (c->type == GSL_BIQUAD_RESONANT_HIGHPASS)
+    f_fn = 1.0 - f_fn;
+  c->f_fn = f_fn;			/* nyquist relative (0=DC, 1=nyquist) */
+  c->gain = gain;
+  c->quality = quality;			/* FIXME */
+  c->k = tan (c->f_fn * GSL_PI / 2.);
+  c->v = pow (10, c->gain / 20.);	/* v=10^(gain[dB]/20) */
+  c->dirty = TRUE;
+  c->approx_values = FALSE;
+}
+
+void
+gsl_biquad_config_approx_freq (GslBiquadConfig *c,
+			       gfloat           f_fn)
+{
+  g_return_if_fail (f_fn >= 0 && f_fn <= 1);
+
+  if (c->type == GSL_BIQUAD_RESONANT_HIGHPASS)
+    f_fn = 1.0 - f_fn;
+  c->f_fn = f_fn;                       /* nyquist relative (0=DC, 1=nyquist) */
+  c->k = tan (c->f_fn * GSL_PI / 2.);	/* FIXME */
+  c->dirty = TRUE;
+  c->approx_values = TRUE;
+}
+
+void
+gsl_biquad_config_approx_gain (GslBiquadConfig *c,
+			       gfloat           gain)
+{
+  c->gain = gain;
+  c->v = gsl_approx_exp2 (c->gain * GSL_LOG2POW20_10);
+  c->dirty = TRUE;
+  c->approx_values = TRUE;
+}
+
+static void
+biquad_lpreso (GslBiquadConfig *c,
+	       GslBiquadFilter *f)
+{
+  gdouble kk, sqrt2_reso, denominator;
+  gdouble r2p_norm = 0;			/* resonance gain to peak gain (pole: -sqrt2_reso+-j) */
+
+  kk = c->k * c->k;
+  sqrt2_reso = 1 / c->v;
+  denominator = 1 + (c->k + sqrt2_reso) * c->k;
+
+  switch (c->normalize)
+    {
+    case GSL_BIQUAD_NORMALIZE_PASSBAND:
+      r2p_norm = kk;
+      break;
+    case GSL_BIQUAD_NORMALIZE_RESONANCE_GAIN:
+      r2p_norm = kk * sqrt2_reso;
+      break;
+    case GSL_BIQUAD_NORMALIZE_PEAK_GAIN:
+      r2p_norm = (GSL_SQRT2 * sqrt2_reso - 1.0) / (sqrt2_reso * sqrt2_reso - 0.5);
+      r2p_norm = r2p_norm > 1 ? kk * sqrt2_reso : kk * r2p_norm * sqrt2_reso;
+      break;
+    }
+  f->xc0 = r2p_norm / denominator;
+  f->xc1 = 2 * f->xc0;
+  f->xc2 = f->xc0;
+  f->yc1 = 2 * (kk - 1) / denominator;
+  f->yc2 = (1 + (c->k - sqrt2_reso) * c->k) / denominator;
+}
+
+void
+gsl_biquad_filter_config (GslBiquadFilter *f,
+			  GslBiquadConfig *c,
+			  gboolean         reset_state)
+{
+  g_return_if_fail (f != NULL);
+  g_return_if_fail (c != NULL);
+
+  if (c->dirty)
+    {
+      switch (c->type)
+	{
+	case GSL_BIQUAD_RESONANT_LOWPASS:
+	  biquad_lpreso (c, f);
+	  break;
+	case GSL_BIQUAD_RESONANT_HIGHPASS:
+	  biquad_lpreso (c, f);
+	  f->xc1 = -f->xc1;
+	  f->yc1 = -f->yc1;
+	  break;
+	default:
+	  g_assert_not_reached ();
+	}
+      c->dirty = FALSE;
+    }
+
+  if (reset_state)
+    f->xd1 = f->xd2 = f->yd1 = f->yd2 = 0;
+}
+
+void
+gsl_biquad_filter_eval (GslBiquadFilter *f,
+			guint            n_values,
+			const gfloat    *x,
+			gfloat          *y)
+{
+  const gfloat *bound;
+  gdouble xc0, xc1, xc2, yc1, yc2, xd1, xd2, yd1, yd2;
+
+  g_return_if_fail (f != NULL && x != NULL && y != NULL);
+
+  xc0 = f->xc0;
+  xc1 = f->xc1;
+  xc2 = f->xc2;
+  yc1 = f->yc1;
+  yc2 = f->yc2;
+  xd1 = f->xd1;
+  xd2 = f->xd2;
+  yd1 = f->yd1;
+  yd2 = f->yd2;
+  bound = x + n_values;
+  while (x < bound)
+    {
+      gdouble k0, k1, k2;
+
+      k2 = xd2 * xc2;
+      k1 = xd1 * xc1;
+      xd2 = xd1;
+      xd1 = *x++;
+      k2 -= yd2 * yc2;
+      k1 -= yd1 * yc1;
+      yd2 = yd1;
+      k0 = xd1 * xc0;
+      yd1 = k2 + k1;
+      *y++ = yd1 += k0;
+    }
+  f->xd1 = xd1;
+  f->xd2 = xd2;
+  f->yd1 = yd1;
+  f->yd2 = yd2;
+}
+
+#if 0
+void
+gsl_biquad_lphp_reso (GslBiquadFilter   *c,
+		      gfloat             f_fn,	/* nyquist relative (0=DC, 1=nyquist) */
+		      float              gain,
+		      gboolean		 design_highpass,
+		      GslBiquadNormalize normalize)
+{
+  double k, kk, v;
+  double sqrt2_reso;
+  double denominator;
+  double r2p_norm = 0;			/* resonance gain to peak gain (pole: -sqrt2_reso+-j) */
+
+  g_return_if_fail (c != NULL);
+  g_return_if_fail (f_fn >= 0 && f_fn <= 1);
+
+  if (design_highpass)
+    f_fn = 1.0 - f_fn;
+
+  v = pow (10, gain / 20.);		/* v=10^(gain[dB]/20) */
+  k = tan (f_fn * GSL_PI / 2.);
+  kk = k * k;
+  sqrt2_reso = 1 / v;
+  denominator = 1 + (k + sqrt2_reso) * k;
+
+  if (0)
+    g_printerr ("BIQUAD-lp: R=%f\n", GSL_SQRT2 * sqrt2_reso);
+
+  switch (normalize)
+    {
+    case GSL_BIQUAD_NORMALIZE_PASSBAND:
+      r2p_norm = kk;
+      break;
+    case GSL_BIQUAD_NORMALIZE_RESONANCE_GAIN:
+      r2p_norm = kk * sqrt2_reso;
+      break;
+    case GSL_BIQUAD_NORMALIZE_PEAK_GAIN:
+      r2p_norm = (GSL_SQRT2 * sqrt2_reso - 1.0) / (sqrt2_reso * sqrt2_reso - 0.5);
+      g_print ("BIQUAD-lp: (peak-gain) r2p_norm = %f \n", r2p_norm);
+      r2p_norm = r2p_norm > 1 ? kk * sqrt2_reso : kk * r2p_norm * sqrt2_reso;
+      break;
+    }
+  c->xc0 = r2p_norm / denominator;
+  c->xc1 = 2 * c->xc0;
+  c->xc2 = c->xc0;
+  c->yc1 = 2 * (kk - 1) / denominator;
+  c->yc2 = (1 + (k - sqrt2_reso) * k) / denominator;
+
+  if (design_highpass)
+    {
+      c->xc1 = -c->xc1;
+      c->yc1 = -c->yc1;
+    }
+  /* normalization notes:
+   * pole: -sqrt2_reso+-j
+   * freq=0.5: reso->peak gain=8adjust:0.9799887, 9adjust:0.98415
+   * resonance gain = 1/(1-R)=sqrt2_reso
+   * sqrt2_reso*(1-R)=1
+   * 1-R=1/sqrt2_reso
+   * R= 1-1/sqrt2_reso
+   * peak gain = 2/(1-R^2)
+   * = 2 * (1 - (1 - 1 / sqrt2_reso) * (1 - 1 / sqrt2_reso))
+   * = 2 - 2 * (1 - 1 / sqrt2_reso)^2
+   */
+}
+#endif
+
+
+/* --- filter scanning -- */
+#define SINE_SCAN_SIZE 1024
+
+/**
+ * gsl_filter_sine_scan
+ *
+ * @order:    order of the iir filter
+ * @a:        root polynomial coefficients of the filter a[0..order]
+ * @b:        pole polynomial coefficients of the filter b[0..order]
+ * @freq:     frequency to test
+ * @n_values: number of samples
+ *
+ * This function sends a sine signal of the desired frequency through an IIR
+ * filter, to test the value of the transfer function at a given point. It uses
+ * gsl_iir_filter_eval to do so.
+ *
+ * Compared to a "mathematical approach" of finding the transfer function,
+ * this function makes it possible to see the effects of finite arithmetic
+ * during filter evaluation.
+ *
+ * The first half of the output signal is not considered, since a lot of IIR
+ * filters have a transient phase where also overshoot is possible.
+ *
+ * For n_values, you should specify a reasonable large value. It should be
+ * a lot larger than the filter order, and large enough to let the input
+ * signal become (close to) 1.0 multiple times.
+ */
+gdouble
+gsl_filter_sine_scan (guint order,
+                      const gdouble *a,
+		      const gdouble *b,
+		      gdouble freq,
+		      guint n_values)
+{
+  gfloat x[SINE_SCAN_SIZE], y[SINE_SCAN_SIZE];
+  gdouble pos = 0.0;
+  gdouble result = 0.0;
+  GslIIRFilter filter;
+  gdouble *filter_state;
+  guint scan_start = n_values / 2;
+
+  g_return_val_if_fail (order > 0, 0.0);
+  g_return_val_if_fail (a != NULL, 0.0);
+  g_return_val_if_fail (b != NULL, 0.0);
+  g_return_val_if_fail (freq > 0 && freq < GSL_PI, 0.0);
+  g_return_val_if_fail (n_values > 0, 0.0);
+
+  filter_state = g_newa (double, (order + 1) * 4);
+  gsl_iir_filter_setup (&filter, order, a, b, filter_state);
+
+  while (n_values)
+    {
+      guint todo = MIN (n_values, SINE_SCAN_SIZE);
+      guint i;
+
+      for (i = 0; i < todo; i++)
+	{
+	  x[i] = sin (pos);
+	  pos += freq;
+	}
+
+      gsl_iir_filter_eval (&filter, SINE_SCAN_SIZE, x, y);
+
+      for (i = 0; i < todo; i++)
+        if (n_values - i < scan_start)
+	  result = MAX (y[i], result);
+
+      n_values -= todo;
+    }
+  return result;
+}
+
+
+
+
+
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gslfilter.h b/flow/gsl/gslfilter.h
new file mode 100644
index 0000000..3baa7e8
--- /dev/null
+++ b/flow/gsl/gslfilter.h
@@ -0,0 +1,281 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Stefan Westerfeld and Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_FILTER_H__
+#define __GSL_FILTER_H__
+
+#include <gsl/gslmath.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- transformations --- */
+static inline GslComplex gsl_trans_s2z          (GslComplex     s);
+static inline double     gsl_trans_freq2s       (double         w);
+static inline double     gsl_trans_zepsilon2ss  (double         epsilon);
+
+
+/* --- filter roots and poles --- */
+void	gsl_filter_butter_rp    (unsigned int iorder,
+				 double       freq,   /* 0..pi */
+				 double       epsilon,
+				 GslComplex  *roots,  /* [0..iorder-1] */
+				 GslComplex  *poles);
+void	gsl_filter_tscheb1_rp	(unsigned int iorder,
+				 double       freq,   /* 0..pi */
+				 double       epsilon,
+				 GslComplex  *roots,  /* [0..iorder-1] */
+				 GslComplex  *poles);
+void	gsl_filter_tscheb2_rp	(unsigned int iorder,
+				 double       c_freq, /* 0..pi */
+				 double       steepness,
+				 double       epsilon,
+				 GslComplex  *roots,  /* [0..iorder-1] */
+				 GslComplex  *poles);
+
+
+/* --- tschebyscheff type II steepness --- */
+double	gsl_filter_tscheb2_steepness_db	(unsigned int iorder,
+					 double       c_freq,
+					 double       epsilon,
+					 double       stopband_db);
+double	gsl_filter_tscheb2_steepness	(unsigned int iorder,
+					 double       c_freq,
+					 double       epsilon,
+					 double       residue);
+
+
+/* --- lowpass filters --- */
+void	gsl_filter_butter_lp    (unsigned int iorder,
+				 double       freq, /* 0..pi */
+				 double       epsilon,
+				 double      *a,    /* [0..iorder] */
+				 double      *b);
+void	gsl_filter_tscheb1_lp	(unsigned int iorder,
+				 double       freq, /* 0..pi */
+				 double       epsilon,
+				 double      *a,    /* [0..iorder] */
+				 double      *b);
+void	gsl_filter_tscheb2_lp	(unsigned int iorder,
+				 double       c_freq, /* 0..pi */
+                                 double       steepness,
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+
+
+/* --- highpass filters --- */
+void	gsl_filter_butter_hp	(unsigned int iorder,
+				 double       freq,   /* 0..pi */
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+void	gsl_filter_tscheb1_hp	(unsigned int iorder,
+				 double       freq,   /* 0..pi */
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+void	gsl_filter_tscheb2_hp	(unsigned int iorder,
+				 double       c_freq, /* 0..pi */
+				 double       steepness,
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+
+
+/* --- bandpass filters --- */
+void	gsl_filter_butter_bp	(unsigned int iorder,
+				 double       freq1,  /* 0..pi */
+				 double       freq2,  /* 0..pi */
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+void	gsl_filter_tscheb1_bp	(unsigned int iorder,
+				 double       freq1,  /* 0..pi */
+				 double       freq2,  /* 0..pi */
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+void	gsl_filter_tscheb2_bp	(unsigned int iorder,
+				 double       freq1,  /* 0..pi */
+				 double       freq2,  /* 0..pi */
+				 double       steepness,
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+
+
+/* --- bandstop filters --- */
+void	gsl_filter_butter_bs	(unsigned int iorder,
+				 double       freq1,  /* 0..pi */
+				 double       freq2,  /* 0..pi */
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+void	gsl_filter_tscheb1_bs	(unsigned int iorder,
+				 double       freq1,  /* 0..pi */
+				 double       freq2,  /* 0..pi */
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+void	gsl_filter_tscheb2_bs	(unsigned int iorder,
+				 double       freq1,  /* 0..pi */
+				 double       freq2,  /* 0..pi */
+				 double       steepness,
+				 double       epsilon,
+				 double      *a,      /* [0..iorder] */
+				 double      *b);
+
+
+/* --- FIR Filters --- */
+void	gsl_filter_fir_approx	(unsigned int  iorder,
+				 double       *a,	/* [0..iorder] */
+				 unsigned int  n_points,
+				 const double *freq,
+				 const double *value);
+
+
+/* --- IIR Filter Evaluation --- */
+typedef struct {
+  guint order;
+  gdouble *a;   /* [0..order] */
+  gdouble *b;   /* [0..order] */
+  gdouble *w;   /* [0..2*order] */
+} GslIIRFilter;
+void	gsl_iir_filter_setup	(GslIIRFilter	*f,
+				 guint		 order,
+				 const gdouble	*a,
+				 const gdouble	*b,
+				 gdouble	*buffer); /* 4*(order+1) */
+void	gsl_iir_filter_change	(GslIIRFilter	*f,
+				 guint		 order,
+				 const gdouble	*a,
+				 const gdouble	*b,
+				 gdouble	*buffer); /* 4*(order+1) */
+void	gsl_iir_filter_eval	(GslIIRFilter	*f,
+				 guint		 n_values,
+				 const gfloat	*x,
+				 gfloat		*y);
+
+
+/* --- Biquad Filters --- */
+typedef enum	/*< skip >*/
+{
+  GSL_BIQUAD_NORMALIZE_PASSBAND,
+  GSL_BIQUAD_NORMALIZE_RESONANCE_GAIN,
+  GSL_BIQUAD_NORMALIZE_PEAK_GAIN
+} GslBiquadNormalize;
+
+typedef enum	/*< skip >*/
+{
+  GSL_BIQUAD_RESONANT_LOWPASS = 1,
+  GSL_BIQUAD_RESONANT_HIGHPASS,
+  GSL_BIQUAD_LOWSHELVE,
+  GSL_BIQUAD_HIGHSHELVE,
+  GSL_BIQUAD_PEAK
+} GslBiquadType;
+
+typedef struct {
+  GslBiquadType      type;
+  GslBiquadNormalize normalize;  	/* high/low pass */
+  gfloat             f_fn;
+  gfloat             gain;
+  gfloat	     quality;		/* peak/notch */
+  guint		     dirty : 1;		/* post filter_config() changes? */
+  guint		     approx_values : 1;	/* biquad_config_approx_*() called? */
+  /*< private >*/
+  gdouble	     k, v;
+} GslBiquadConfig;
+
+typedef struct {
+  gdouble xc0, xc1, xc2;
+  gdouble yc1, yc2; /* yc0==1 */
+  gdouble xd1, xd2, yd1, yd2; /* history */
+} GslBiquadFilter;
+
+void	gsl_biquad_config_init		(GslBiquadConfig	*c,
+					 GslBiquadType		 type,
+					 GslBiquadNormalize	 normalize);
+void	gsl_biquad_config_setup		(GslBiquadConfig	*c,
+					 gfloat			 f_fn,
+					 gfloat			 gain,
+					 gfloat			 quality);
+void	gsl_biquad_config_approx_freq	(GslBiquadConfig	*c,
+					 gfloat			 f_fn);
+void	gsl_biquad_config_approx_gain	(GslBiquadConfig	*c,
+					 gfloat			 gain);
+void	gsl_biquad_filter_config	(GslBiquadFilter	*f,
+					 GslBiquadConfig	*c,
+					 gboolean		 reset_state);
+void	gsl_biquad_filter_eval		(GslBiquadFilter	*f,
+					 guint			 n_values,
+					 const gfloat		*x,
+					 gfloat			*y);
+
+
+/* --- filter scanning -- */
+gdouble	gsl_filter_sine_scan	(guint		 order,
+				 const gdouble	*a,
+				 const gdouble	*b,
+				 gdouble	 freq,
+				 guint		 n_values);
+
+
+/* --- implementations --- */
+static inline GslComplex
+gsl_trans_s2z (GslComplex s)
+{
+  /*       1 + (Td/2) * s
+   *  z = ----------------
+   *       1 - (Td/2) * s
+   */
+  GslComplex one = { 1, 0 };
+  return gsl_complex_div (gsl_complex_add (one, s), gsl_complex_sub (one, s));
+  /* return gsl_complex_div (gsl_complex_sub (s, one), gsl_complex_add (s, one)); */
+}
+static inline double
+gsl_trans_freq2s (double w)
+{
+  return tan (w / 2.);
+}
+static inline double
+gsl_trans_zepsilon2ss (double zepsilon)
+{
+  double e2 = (1.0 - zepsilon) * (1.0 - zepsilon);
+  /* 1___                                      _________________
+   * |   \                                    |       1.0
+   * |-----\<---- 1 - zepsilon  zepsilon = \  | ----------------
+   * |_______\________________               \|  1 + sepsilon^2
+   */
+  return sqrt ((1.0 - e2) / e2);
+}
+static inline double
+gsl_trans_freq2z (double w)
+{
+  return atan (w) * 2.;
+}
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_FILTER_H__ */	/* vim:set ts=8 sw=2 sts=2: */
diff --git a/flow/gsl/gslglib.c b/flow/gsl/gslglib.c
new file mode 100644
index 0000000..f913df2
--- /dev/null
+++ b/flow/gsl/gslglib.c
@@ -0,0 +1,2400 @@
+#include "gsl/gslglib.h"
+#include "gsl/gsldefs.h"
+
+#include <locale.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#define	GLIB_SIZEOF_INTMAX	(GSL_SIZEOF_STD_INTMAX_T ? GSL_SIZEOF_STD_INTMAX_T : 8 /* educated guess */)
+
+gpointer g_malloc         (gulong        n_bytes) { void*p = malloc(n_bytes); GSL_ASSERT(p!=0); return p; }
+gpointer g_malloc0        (gulong        n_bytes) { return memset(g_malloc(n_bytes),0,n_bytes); }
+gpointer g_realloc        (gpointer      mem,
+			   gulong        n_bytes) { void*p = realloc(mem,n_bytes); GSL_ASSERT(p!=0); return p; }
+void     g_free           (gpointer      mem) { if (mem) free(mem); }
+void g_usleep (unsigned long usec) { usleep (usec); }
+char* g_strerror(int e) { return strerror (e); }
+
+
+gpointer g_memdup (gconstpointer mem,  guint  byte_size) { gpointer new_mem; if (mem)  {    new_mem = g_malloc (byte_size);  memcpy (new_mem, mem, byte_size);  } else  new_mem = NULL;  return new_mem; }
+gchar* g_strdup (const gchar *str) {   gchar *new_str;   if (str)   {    new_str = g_new (char, strlen (str) + 1);     strcpy (new_str, str);    }   else   new_str = NULL;   return new_str; }
+gchar* g_strndup (const gchar *str,   gsize        n) {   gchar *new_str;   if (str)    {      new_str = g_new (gchar, n + 1);       strncpy (new_str, str, n);       new_str[n] = '\0';     }   else     new_str = NULL;   return new_str; }
+gchar*g_strconcat (const gchar *string1, ...){  gsize   l;  va_list args;  gchar   *s;  gchar   *concat;  gchar   *ptr;  g_return_val_if_fail (string1 != NULL, NULL);  l = 1 + strlen (string1);  va_start (args, string1);  s = va_arg (args, gchar*);  while (s)    {      l += strlen (s);      s = va_arg (args, gchar*);    }  va_end (args);  concat = g_new (gchar, l);  ptr = concat;  ptr = g_stpcpy (ptr, string1);  va_start (args, string1);  s = va_arg (args, gchar*);  while (s)    {      ptr = g_stpcpy (ptr, s);       s = va_arg (args, gchar*);     }   va_end (args);  return concat; }
+
+gchar*
+g_strdup_printf (const gchar *format,
+		 ...)
+{
+  gchar *buffer;
+  va_list args;
+
+  va_start (args, format);
+  buffer = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  return buffer;
+}
+
+
+gchar*
+g_strdup_vprintf (const gchar *format,
+		  va_list      args1)
+{
+  gchar *buffer;
+#ifdef HAVE_VASPRINTF
+  if (vasprintf (&buffer, format, args1) < 0)
+    buffer = NULL;
+#else
+  va_list args2;
+
+  G_VA_COPY (args2, args1);
+
+  buffer = g_new (gchar, g_printf_string_upper_bound (format, args1));
+
+  vsprintf (buffer, format, args2);
+  va_end (args2);
+#endif
+  return buffer;
+}
+gchar *
+g_stpcpy (gchar       *dest,
+	  const gchar *src)
+{
+#ifdef GLIB_HAVE_STPCPY
+  g_return_val_if_fail (dest != NULL, NULL);
+  g_return_val_if_fail (src != NULL, NULL);
+  return stpcpy (dest, src);
+#else
+  register gchar *d = dest;
+  register const gchar *s = src;
+
+  g_return_val_if_fail (dest != NULL, NULL);
+  g_return_val_if_fail (src != NULL, NULL);
+  do
+    *d++ = *s;
+  while (*s++ != '\0');
+
+  return d - 1;
+#endif
+}
+
+gchar *
+g_strescape (const gchar *source,
+	     const gchar *exceptions)
+{
+  const guchar *p;
+  gchar *dest;
+  gchar *q;
+  guchar excmap[256];
+  
+  g_return_val_if_fail (source != NULL, NULL);
+
+  p = (guchar *) source;
+  /* Each source byte needs maximally four destination chars (\777) */
+  q = dest = g_malloc (strlen (source) * 4 + 1);
+
+  memset (excmap, 0, 256);
+  if (exceptions)
+    {
+      guchar *e = (guchar *) exceptions;
+
+      while (*e)
+	{
+	  excmap[*e] = 1;
+	  e++;
+	}
+    }
+
+  while (*p)
+    {
+      if (excmap[*p])
+	*q++ = *p;
+      else
+	{
+	  switch (*p)
+	    {
+	    case '\b':
+	      *q++ = '\\';
+	      *q++ = 'b';
+	      break;
+	    case '\f':
+	      *q++ = '\\';
+	      *q++ = 'f';
+	      break;
+	    case '\n':
+	      *q++ = '\\';
+	      *q++ = 'n';
+	      break;
+	    case '\r':
+	      *q++ = '\\';
+	      *q++ = 'r';
+	      break;
+	    case '\t':
+	      *q++ = '\\';
+	      *q++ = 't';
+	      break;
+	    case '\\':
+	      *q++ = '\\';
+	      *q++ = '\\';
+	      break;
+	    case '"':
+	      *q++ = '\\';
+	      *q++ = '"';
+	      break;
+	    default:
+	      if ((*p < ' ') || (*p >= 0177))
+		{
+		  *q++ = '\\';
+		  *q++ = '0' + (((*p) >> 6) & 07);
+		  *q++ = '0' + (((*p) >> 3) & 07);
+		  *q++ = '0' + ((*p) & 07);
+		}
+	      else
+		*q++ = *p;
+	      break;
+	    }
+	}
+      p++;
+    }
+  *q = 0;
+  return dest;
+}
+
+
+
+
+guint g_direct_hash (gconstpointer v) {   return GPOINTER_TO_UINT (v); }
+gboolean g_direct_equal (gconstpointer v1, gconstpointer v2) {   return v1 == v2; }
+gboolean g_str_equal (gconstpointer v1,   gconstpointer v2) { const gchar *string1 = v1; const gchar *string2 = v2; return strcmp (string1, string2) == 0; }
+guint g_str_hash (gconstpointer key) {   const char *p = key;   guint h = *p;   if (h)     for (p += 1; *p != '\0'; p++)       h = (h << 5) - h + *p;   return h; }
+
+
+void
+gsl_g_log (const gchar*msg,const char *format, va_list ap)
+{
+  if (msg) printf ("\n%s",msg);
+  vprintf(format, ap);
+  if (msg) printf ("\n");
+}
+
+void
+gsl_g_print_fd (int fd, const char *format, va_list ap)
+{
+  g_return_if_fail (fd == 1 || fd == 2);
+  if (fd == 1)
+    vprintf (format, ap);
+  else
+    vfprintf (stderr, format, ap);
+}
+
+gchar*
+gsl_g_convert (const gchar  *str,
+	       gsize        len,            /* gssize */
+	       const gchar  *to_codeset,
+	       const gchar  *from_codeset,
+	       gsize        *bytes_read,
+	       gsize        *bytes_written,
+	       void         **error)        /* GError */
+{
+  g_error ("g_convert not implemented");
+  
+  /* not reached: */
+  return 0;
+}
+
+
+/* --- GScanner --- */
+
+#ifdef HAVE_SNPRINTF
+/* FIXME: might want to do the configure test in gsl instead of arts */
+#define g_snprintf snprintf
+#else
+#define g_snprintf gsl_g_snprintf
+static void
+gsl_g_snprintf (gchar        *out_buffer,
+		size_t        size,
+		const gchar  *format,
+		...)
+{
+  gchar *buffer;
+  va_list args;
+  
+  /* print string into large enough buffer */
+  va_start (args, format);
+  buffer = g_strdup_printf (format, args);
+  va_end (args);
+  
+  /* copy the first size bytes into out_buffer */
+  strncpy (out_buffer, buffer, size);
+  out_buffer[ size - 1 ] = '\0';
+  g_free (buffer);
+}
+#endif
+
+
+struct _GString
+{
+  gchar *str;
+  guint len;
+};
+
+static GString*
+g_string_new(const gchar* s)
+{
+  GString *gstr=g_new0(GString,1);
+  gstr->str= g_strdup(s);
+  gstr->len=strlen(s);
+  return gstr;
+}
+static GString*
+g_string_append_c(GString*gstr, int ch)
+{
+  gstr->str=g_renew(gchar,gstr->str,++gstr->len + 1);
+  gstr->str[gstr->len-1]=ch;
+  gstr->str[gstr->len]=0;
+  return gstr;
+}
+static void
+g_string_free(GString*gstr, int freeme)
+{
+  if(freeme)g_free(gstr->str);g_free(gstr);
+}
+
+
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * GScanner: Flexible lexical scanner for general purpose.
+ * Copyright (C) 1997, 1998 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+/* 
+ * MT safe
+ */
+
+
+#include	<stdlib.h>
+#include	<stdarg.h>
+#include	<string.h>
+#include	<stdio.h>
+#include	<unistd.h>
+#include	<errno.h>
+
+/* --- defines --- */
+#define	to_lower(c)				( \
+	(guchar) (							\
+	  ( (((guchar)(c))>='A' && ((guchar)(c))<='Z') * ('a'-'A') ) |	\
+	  ( (((guchar)(c))>=192 && ((guchar)(c))<=214) * (224-192) ) |	\
+	  ( (((guchar)(c))>=216 && ((guchar)(c))<=222) * (248-216) ) |	\
+	  ((guchar)(c))							\
+	)								\
+)
+#define	READ_BUFFER_SIZE	(4000)
+
+
+/* --- typedefs --- */
+typedef	struct	_GScannerKey	GScannerKey;
+
+struct	_GScannerKey
+{
+  guint		 scope_id;
+  gchar		*symbol;
+  gpointer	 value;
+};
+
+
+
+/* --- variables --- */
+#define g_scanner_config_template _cplusplus_wont_have_a_problem_with_this_foog_scanner_config_template
+static GScannerConfig g_scanner_config_template =
+{
+  (
+   " \t\r\n"
+   )			/* cset_skip_characters */,
+  (
+   G_CSET_a_2_z
+   "_"
+   G_CSET_A_2_Z
+   )			/* cset_identifier_first */,
+  (
+   G_CSET_a_2_z
+   "_"
+   G_CSET_A_2_Z
+   G_CSET_DIGITS
+   G_CSET_LATINS
+   G_CSET_LATINC
+   )			/* cset_identifier_nth */,
+  ( "#\n" )		/* cpair_comment_single */,
+  
+  FALSE			/* case_sensitive */,
+  
+  TRUE			/* skip_comment_multi */,
+  TRUE			/* skip_comment_single */,
+  TRUE			/* scan_comment_multi */,
+  TRUE			/* scan_identifier */,
+  FALSE			/* scan_identifier_1char */,
+  FALSE			/* scan_identifier_NULL */,
+  TRUE			/* scan_symbols */,
+  FALSE			/* scan_binary */,
+  TRUE			/* scan_octal */,
+  TRUE			/* scan_float */,
+  TRUE			/* scan_hex */,
+  FALSE			/* scan_hex_dollar */,
+  TRUE			/* scan_string_sq */,
+  TRUE			/* scan_string_dq */,
+  TRUE			/* numbers_2_int */,
+  FALSE			/* int_2_float */,
+  FALSE			/* identifier_2_string */,
+  TRUE			/* char_2_token */,
+  FALSE			/* symbol_2_token */,
+  FALSE			/* scope_0_fallback */,
+};
+
+
+/* --- prototypes --- */
+static inline
+GScannerKey*	g_scanner_lookup_internal (GScanner	*scanner,
+					   guint	 scope_id,
+					   const gchar	*symbol);
+static gboolean	g_scanner_key_equal	  (gconstpointer v1,
+					   gconstpointer v2);
+static guint	g_scanner_key_hash	  (gconstpointer v);
+static void	g_scanner_get_token_ll	  (GScanner	*scanner,
+					   GTokenType	*token_p,
+					   GTokenValue	*value_p,
+					   guint	*line_p,
+					   guint	*position_p);
+static void	g_scanner_get_token_i	  (GScanner	*scanner,
+					   GTokenType	*token_p,
+					   GTokenValue	*value_p,
+					   guint	*line_p,
+					   guint	*position_p);
+
+static guchar	g_scanner_peek_next_char  (GScanner	*scanner);
+static guchar	g_scanner_get_char	  (GScanner	*scanner,
+					   guint	*line_p,
+					   guint	*position_p);
+static void	g_scanner_msg_handler	  (GScanner	*scanner,
+					   gchar	*message,
+					   gint		 is_error);
+
+
+/* --- functions --- */
+static inline gint
+g_scanner_char_2_num (guchar	c,
+		      guchar	base)
+{
+  if (c >= '0' && c <= '9')
+    c -= '0';
+  else if (c >= 'A' && c <= 'Z')
+    c -= 'A' - 10;
+  else if (c >= 'a' && c <= 'z')
+    c -= 'a' - 10;
+  else
+    return -1;
+  
+  if (c < base)
+    return c;
+  
+  return -1;
+}
+
+GScanner*
+g_scanner_new (const GScannerConfig *config_templ)
+{
+  GScanner *scanner;
+  
+  if (!config_templ)
+    config_templ = &g_scanner_config_template;
+  
+  scanner = g_new0 (GScanner, 1);
+  
+  scanner->user_data = NULL;
+  scanner->max_parse_errors = 0;
+  scanner->parse_errors	= 0;
+  scanner->input_name = NULL;
+  /* g_datalist_init (&scanner->qdata); */
+  
+  scanner->config = g_new0 (GScannerConfig, 1);
+  
+  scanner->config->case_sensitive	 = config_templ->case_sensitive;
+  scanner->config->cset_skip_characters	 = config_templ->cset_skip_characters;
+  if (!scanner->config->cset_skip_characters)
+    scanner->config->cset_skip_characters = "";
+  scanner->config->cset_identifier_first = config_templ->cset_identifier_first;
+  scanner->config->cset_identifier_nth	 = config_templ->cset_identifier_nth;
+  scanner->config->cpair_comment_single	 = config_templ->cpair_comment_single;
+  scanner->config->skip_comment_multi	 = config_templ->skip_comment_multi;
+  scanner->config->skip_comment_single	 = config_templ->skip_comment_single;
+  scanner->config->scan_comment_multi	 = config_templ->scan_comment_multi;
+  scanner->config->scan_identifier	 = config_templ->scan_identifier;
+  scanner->config->scan_identifier_1char = config_templ->scan_identifier_1char;
+  scanner->config->scan_identifier_NULL	 = config_templ->scan_identifier_NULL;
+  scanner->config->scan_symbols		 = config_templ->scan_symbols;
+  scanner->config->scan_binary		 = config_templ->scan_binary;
+  scanner->config->scan_octal		 = config_templ->scan_octal;
+  scanner->config->scan_float		 = config_templ->scan_float;
+  scanner->config->scan_hex		 = config_templ->scan_hex;
+  scanner->config->scan_hex_dollar	 = config_templ->scan_hex_dollar;
+  scanner->config->scan_string_sq	 = config_templ->scan_string_sq;
+  scanner->config->scan_string_dq	 = config_templ->scan_string_dq;
+  scanner->config->numbers_2_int	 = config_templ->numbers_2_int;
+  scanner->config->int_2_float		 = config_templ->int_2_float;
+  scanner->config->identifier_2_string	 = config_templ->identifier_2_string;
+  scanner->config->char_2_token		 = config_templ->char_2_token;
+  scanner->config->symbol_2_token	 = config_templ->symbol_2_token;
+  scanner->config->scope_0_fallback	 = config_templ->scope_0_fallback;
+  
+  scanner->token = G_TOKEN_NONE;
+  scanner->value.v_int = 0;
+  scanner->line = 1;
+  scanner->position = 0;
+  
+  scanner->next_token = G_TOKEN_NONE;
+  scanner->next_value.v_int = 0;
+  scanner->next_line = 1;
+  scanner->next_position = 0;
+  
+  scanner->symbol_table = g_hash_table_new (g_scanner_key_hash, g_scanner_key_equal);
+  scanner->input_fd = -1;
+  scanner->text = NULL;
+  scanner->text_end = NULL;
+  scanner->buffer = NULL;
+  scanner->scope_id = 0;
+  
+  scanner->msg_handler = g_scanner_msg_handler;
+  
+  return scanner;
+}
+
+static inline void
+g_scanner_free_value (GTokenType     *token_p,
+		      GTokenValue     *value_p)
+{
+  switch (*token_p)
+    {
+    case G_TOKEN_STRING:
+    case G_TOKEN_IDENTIFIER:
+    case G_TOKEN_IDENTIFIER_NULL:
+    case G_TOKEN_COMMENT_SINGLE:
+    case G_TOKEN_COMMENT_MULTI:
+      g_free (value_p->v_string);
+      break;
+      
+    default:
+      break;
+    }
+  
+  *token_p = G_TOKEN_NONE;
+}
+
+static void
+g_scanner_destroy_symbol_table_entry (gpointer _key,
+				      gpointer _value,
+				      gpointer _data)
+{
+  GScannerKey *key = _key;
+  
+  g_free (key->symbol);
+  g_free (key);
+}
+
+void
+g_scanner_destroy (GScanner	*scanner)
+{
+  g_return_if_fail (scanner != NULL);
+  
+  /* g_datalist_clear (&scanner->qdata); */
+  g_hash_table_foreach (scanner->symbol_table, 
+			g_scanner_destroy_symbol_table_entry, NULL);
+  g_hash_table_destroy (scanner->symbol_table);
+  g_scanner_free_value (&scanner->token, &scanner->value);
+  g_scanner_free_value (&scanner->next_token, &scanner->next_value);
+  g_free (scanner->config);
+  g_free (scanner->buffer);
+  g_free (scanner);
+}
+
+static void
+g_scanner_msg_handler (GScanner		*scanner,
+		       gchar		*message,
+		       gint		 is_error)
+{
+  g_return_if_fail (scanner != NULL);
+  
+  fprintf (stderr, "%s:%d: ", scanner->input_name, scanner->line);
+  if (is_error)
+    fprintf (stderr, "error: ");
+  fprintf (stderr, "%s\n", message);
+}
+
+void
+g_scanner_error (GScanner	*scanner,
+		 const gchar	*format,
+		 ...)
+{
+  g_return_if_fail (scanner != NULL);
+  g_return_if_fail (format != NULL);
+  
+  scanner->parse_errors++;
+  
+  if (scanner->msg_handler)
+    {
+      va_list args;
+      gchar *string;
+      
+      va_start (args, format);
+      string = g_strdup_vprintf (format, args);
+      va_end (args);
+      
+      scanner->msg_handler (scanner, string, TRUE);
+      
+      g_free (string);
+    }
+}
+
+void
+g_scanner_warn (GScanner       *scanner,
+		const gchar    *format,
+		...)
+{
+  g_return_if_fail (scanner != NULL);
+  g_return_if_fail (format != NULL);
+  
+  if (scanner->msg_handler)
+    {
+      va_list args;
+      gchar *string;
+      
+      va_start (args, format);
+      string = g_strdup_vprintf (format, args);
+      va_end (args);
+      
+      scanner->msg_handler (scanner, string, FALSE);
+      
+      g_free (string);
+    }
+}
+
+static gboolean
+g_scanner_key_equal (gconstpointer v1,
+		     gconstpointer v2)
+{
+  const GScannerKey *key1 = v1;
+  const GScannerKey *key2 = v2;
+  
+  return (key1->scope_id == key2->scope_id) && (strcmp (key1->symbol, key2->symbol) == 0);
+}
+
+static guint
+g_scanner_key_hash (gconstpointer v)
+{
+  const GScannerKey *key = v;
+  gchar *c;
+  guint h;
+  
+  h = key->scope_id;
+  for (c = key->symbol; *c; c++)
+    h = (h << 5) - h + *c;
+  
+  return h;
+}
+
+static inline GScannerKey*
+g_scanner_lookup_internal (GScanner	*scanner,
+			   guint	 scope_id,
+			   const gchar	*symbol)
+{
+  GScannerKey	*key_p;
+  GScannerKey key;
+  
+  key.scope_id = scope_id;
+  
+  if (!scanner->config->case_sensitive)
+    {
+      gchar *d;
+      const gchar *c;
+      
+      key.symbol = g_new (gchar, strlen (symbol) + 1);
+      for (d = key.symbol, c = symbol; *c; c++, d++)
+	*d = to_lower (*c);
+      *d = 0;
+      key_p = g_hash_table_lookup (scanner->symbol_table, &key);
+      g_free (key.symbol);
+    }
+  else
+    {
+      key.symbol = (gchar*) symbol;
+      key_p = g_hash_table_lookup (scanner->symbol_table, &key);
+    }
+  
+  return key_p;
+}
+
+void
+g_scanner_scope_add_symbol (GScanner	*scanner,
+			    guint	 scope_id,
+			    const gchar	*symbol,
+			    gpointer	 value)
+{
+  GScannerKey	*key;
+  
+  g_return_if_fail (scanner != NULL);
+  g_return_if_fail (symbol != NULL);
+  
+  key = g_scanner_lookup_internal (scanner, scope_id, symbol);
+  
+  if (!key)
+    {
+      key = g_new (GScannerKey, 1);
+      key->scope_id = scope_id;
+      key->symbol = g_strdup (symbol);
+      key->value = value;
+      if (!scanner->config->case_sensitive)
+	{
+	  gchar *c;
+	  
+	  c = key->symbol;
+	  while (*c != 0)
+	    {
+	      *c = to_lower (*c);
+	      c++;
+	    }
+	}
+      g_hash_table_insert (scanner->symbol_table, key, key);
+    }
+  else
+    key->value = value;
+}
+
+void
+g_scanner_scope_remove_symbol (GScanner	   *scanner,
+			       guint	    scope_id,
+			       const gchar *symbol)
+{
+  GScannerKey	*key;
+  
+  g_return_if_fail (scanner != NULL);
+  g_return_if_fail (symbol != NULL);
+  
+  key = g_scanner_lookup_internal (scanner, scope_id, symbol);
+  
+  if (key)
+    {
+      g_hash_table_remove (scanner->symbol_table, key);
+      g_free (key->symbol);
+      g_free (key);
+    }
+}
+
+gpointer
+g_scanner_lookup_symbol (GScanner	*scanner,
+			 const gchar	*symbol)
+{
+  GScannerKey	*key;
+  guint scope_id;
+  
+  g_return_val_if_fail (scanner != NULL, NULL);
+  
+  if (!symbol)
+    return NULL;
+  
+  scope_id = scanner->scope_id;
+  key = g_scanner_lookup_internal (scanner, scope_id, symbol);
+  if (!key && scope_id && scanner->config->scope_0_fallback)
+    key = g_scanner_lookup_internal (scanner, 0, symbol);
+  
+  if (key)
+    return key->value;
+  else
+    return NULL;
+}
+
+gpointer
+g_scanner_scope_lookup_symbol (GScanner	      *scanner,
+			       guint	       scope_id,
+			       const gchar    *symbol)
+{
+  GScannerKey	*key;
+  
+  g_return_val_if_fail (scanner != NULL, NULL);
+  
+  if (!symbol)
+    return NULL;
+  
+  key = g_scanner_lookup_internal (scanner, scope_id, symbol);
+  
+  if (key)
+    return key->value;
+  else
+    return NULL;
+}
+
+guint
+g_scanner_set_scope (GScanner	    *scanner,
+		     guint	     scope_id)
+{
+  guint old_scope_id;
+  
+  g_return_val_if_fail (scanner != NULL, 0);
+  
+  old_scope_id = scanner->scope_id;
+  scanner->scope_id = scope_id;
+  
+  return old_scope_id;
+}
+
+static void
+g_scanner_foreach_internal (gpointer  _key,
+			    gpointer  _value,
+			    gpointer  _user_data)
+{
+  GScannerKey *key;
+  gpointer *d;
+  GHFunc func;
+  gpointer user_data;
+  guint *scope_id;
+  
+  d = _user_data;
+  func = (GHFunc) d[0];
+  user_data = d[1];
+  scope_id = d[2];
+  key = _value;
+  
+  if (key->scope_id == *scope_id)
+    func (key->symbol, key->value, user_data);
+}
+
+void
+g_scanner_scope_foreach_symbol (GScanner       *scanner,
+				guint		scope_id,
+				GHFunc		func,
+				gpointer	user_data)
+{
+  gpointer d[3];
+  
+  g_return_if_fail (scanner != NULL);
+  
+  d[0] = (gpointer) func;
+  d[1] = user_data;
+  d[2] = &scope_id;
+  
+  g_hash_table_foreach (scanner->symbol_table, g_scanner_foreach_internal, d);
+}
+
+GTokenType
+g_scanner_peek_next_token (GScanner	*scanner)
+{
+  g_return_val_if_fail (scanner != NULL, G_TOKEN_EOF);
+  
+  if (scanner->next_token == G_TOKEN_NONE)
+    {
+      scanner->next_line = scanner->line;
+      scanner->next_position = scanner->position;
+      g_scanner_get_token_i (scanner,
+			     &scanner->next_token,
+			     &scanner->next_value,
+			     &scanner->next_line,
+			     &scanner->next_position);
+    }
+  
+  return scanner->next_token;
+}
+
+GTokenType
+g_scanner_get_next_token (GScanner	*scanner)
+{
+  g_return_val_if_fail (scanner != NULL, G_TOKEN_EOF);
+  
+  if (scanner->next_token != G_TOKEN_NONE)
+    {
+      g_scanner_free_value (&scanner->token, &scanner->value);
+      
+      scanner->token = scanner->next_token;
+      scanner->value = scanner->next_value;
+      scanner->line = scanner->next_line;
+      scanner->position = scanner->next_position;
+      scanner->next_token = G_TOKEN_NONE;
+    }
+  else
+    g_scanner_get_token_i (scanner,
+			   &scanner->token,
+			   &scanner->value,
+			   &scanner->line,
+			   &scanner->position);
+  
+  return scanner->token;
+}
+
+GTokenType
+g_scanner_cur_token (GScanner *scanner)
+{
+  g_return_val_if_fail (scanner != NULL, G_TOKEN_EOF);
+  
+  return scanner->token;
+}
+
+GTokenValue
+g_scanner_cur_value (GScanner *scanner)
+{
+  GTokenValue v;
+  
+  v.v_int = 0;
+  
+  g_return_val_if_fail (scanner != NULL, v);
+
+  /* MSC isn't capable of handling return scanner->value; ? */
+
+  v = scanner->value;
+
+  return v;
+}
+
+guint
+g_scanner_cur_line (GScanner *scanner)
+{
+  g_return_val_if_fail (scanner != NULL, 0);
+  
+  return scanner->line;
+}
+
+guint
+g_scanner_cur_position (GScanner *scanner)
+{
+  g_return_val_if_fail (scanner != NULL, 0);
+  
+  return scanner->position;
+}
+
+gboolean
+g_scanner_eof (GScanner	*scanner)
+{
+  g_return_val_if_fail (scanner != NULL, TRUE);
+  
+  return scanner->token == G_TOKEN_EOF;
+}
+
+void
+g_scanner_input_file (GScanner *scanner,
+		      gint	input_fd)
+{
+  g_return_if_fail (scanner != NULL);
+  g_return_if_fail (input_fd >= 0);
+
+  if (scanner->input_fd >= 0)
+    g_scanner_sync_file_offset (scanner);
+
+  scanner->token = G_TOKEN_NONE;
+  scanner->value.v_int = 0;
+  scanner->line = 1;
+  scanner->position = 0;
+  scanner->next_token = G_TOKEN_NONE;
+
+  scanner->input_fd = input_fd;
+  scanner->text = NULL;
+  scanner->text_end = NULL;
+
+  if (!scanner->buffer)
+    scanner->buffer = g_new (gchar, READ_BUFFER_SIZE + 1);
+}
+
+void
+g_scanner_input_text (GScanner	  *scanner,
+		      const gchar *text,
+		      guint	   text_len)
+{
+  g_return_if_fail (scanner != NULL);
+  if (text_len)
+    g_return_if_fail (text != NULL);
+  else
+    text = NULL;
+
+  if (scanner->input_fd >= 0)
+    g_scanner_sync_file_offset (scanner);
+
+  scanner->token = G_TOKEN_NONE;
+  scanner->value.v_int = 0;
+  scanner->line = 1;
+  scanner->position = 0;
+  scanner->next_token = G_TOKEN_NONE;
+
+  scanner->input_fd = -1;
+  scanner->text = text;
+  scanner->text_end = text + text_len;
+
+  if (scanner->buffer)
+    {
+      g_free (scanner->buffer);
+      scanner->buffer = NULL;
+    }
+}
+
+static guchar
+g_scanner_peek_next_char (GScanner *scanner)
+{
+  if (scanner->text < scanner->text_end)
+    {
+      return *scanner->text;
+    }
+  else if (scanner->input_fd >= 0)
+    {
+      gint count;
+      gchar *buffer;
+
+      buffer = scanner->buffer;
+      do
+	{
+	  count = read (scanner->input_fd, buffer, READ_BUFFER_SIZE);
+	}
+      while (count == -1 && (errno == EINTR || errno == EAGAIN));
+
+      if (count < 1)
+	{
+	  scanner->input_fd = -1;
+
+	  return 0;
+	}
+      else
+	{
+	  scanner->text = buffer;
+	  scanner->text_end = buffer + count;
+
+	  return *buffer;
+	}
+    }
+  else
+    return 0;
+}
+
+void
+g_scanner_sync_file_offset (GScanner *scanner)
+{
+  g_return_if_fail (scanner != NULL);
+
+  /* for file input, rewind the filedescriptor to the current
+   * buffer position and blow the file read ahead buffer. useful for
+   * third party uses of our filedescriptor, which hooks onto the current
+   * scanning position.
+   */
+
+  if (scanner->input_fd >= 0 && scanner->text_end > scanner->text)
+    {
+      gint buffered;
+
+      buffered = scanner->text_end - scanner->text;
+      if (lseek (scanner->input_fd, - buffered, SEEK_CUR) >= 0)
+	{
+	  /* we succeeded, blow our buffer's contents now */
+	  scanner->text = NULL;
+	  scanner->text_end = NULL;
+	}
+      else
+	errno = 0;
+    }
+}
+
+static guchar
+g_scanner_get_char (GScanner	*scanner,
+		    guint	*line_p,
+		    guint	*position_p)
+{
+  guchar fchar;
+
+  if (scanner->text < scanner->text_end)
+    fchar = *(scanner->text++);
+  else if (scanner->input_fd >= 0)
+    {
+      gint count;
+      gchar *buffer;
+
+      buffer = scanner->buffer;
+      do
+	{
+	  count = read (scanner->input_fd, buffer, READ_BUFFER_SIZE);
+	}
+      while (count == -1 && (errno == EINTR || errno == EAGAIN));
+
+      if (count < 1)
+	{
+	  scanner->input_fd = -1;
+	  fchar = 0;
+	}
+      else
+	{
+	  scanner->text = buffer + 1;
+	  scanner->text_end = buffer + count;
+	  fchar = *buffer;
+	  if (!fchar)
+	    {
+	      g_scanner_sync_file_offset (scanner);
+	      scanner->text_end = scanner->text;
+	      scanner->input_fd = -1;
+	    }
+	}
+    }
+  else
+    fchar = 0;
+  
+  if (fchar == '\n')
+    {
+      (*position_p) = 0;
+      (*line_p)++;
+    }
+  else if (fchar)
+    {
+      (*position_p)++;
+    }
+  
+  return fchar;
+}
+
+void
+g_scanner_unexp_token (GScanner		*scanner,
+		       GTokenType	 expected_token,
+		       const gchar	*identifier_spec,
+		       const gchar	*symbol_spec,
+		       const gchar	*symbol_name,
+		       const gchar	*message,
+		       gint		 is_error)
+{
+  gchar	*token_string;
+  guint	token_string_len;
+  gchar	*expected_string;
+  guint	expected_string_len;
+  const gchar *message_prefix;
+  gboolean print_unexp;
+  void (*msg_handler)	(GScanner*, const gchar*, ...);
+  
+  g_return_if_fail (scanner != NULL);
+  
+  if (is_error)
+    msg_handler = g_scanner_error;
+  else
+    msg_handler = g_scanner_warn;
+  
+  if (!identifier_spec)
+    identifier_spec = "identifier";
+  if (!symbol_spec)
+    symbol_spec = "symbol";
+  
+  token_string_len = 56;
+  token_string = g_new (gchar, token_string_len + 1);
+  expected_string_len = 64;
+  expected_string = g_new (gchar, expected_string_len + 1);
+  print_unexp = TRUE;
+  
+  switch (scanner->token)
+    {
+    case G_TOKEN_EOF:
+      g_snprintf (token_string, token_string_len, "end of file");
+      break;
+      
+    default:
+      if (scanner->token >= 1 && scanner->token <= 255)
+	{
+	  if ((scanner->token >= ' ' && scanner->token <= '~') ||
+	      strchr (scanner->config->cset_identifier_first, scanner->token) ||
+	      strchr (scanner->config->cset_identifier_nth, scanner->token))
+	    g_snprintf (token_string, expected_string_len, "character `%c'", scanner->token);
+	  else
+	    g_snprintf (token_string, expected_string_len, "character `\\%o'", scanner->token);
+	  break;
+	}
+      else if (!scanner->config->symbol_2_token)
+	{
+	  g_snprintf (token_string, token_string_len, "(unknown) token <%d>", scanner->token);
+	  break;
+	}
+      /* fall through */
+    case G_TOKEN_SYMBOL:
+      if (expected_token == G_TOKEN_SYMBOL ||
+	  (scanner->config->symbol_2_token &&
+	   expected_token > G_TOKEN_LAST))
+	print_unexp = FALSE;
+      if (symbol_name)
+	g_snprintf (token_string,
+		    token_string_len,
+		    "%s%s `%s'",
+		    print_unexp ? "" : "invalid ",
+		    symbol_spec,
+		    symbol_name);
+      else
+	g_snprintf (token_string,
+		    token_string_len,
+		    "%s%s",
+		    print_unexp ? "" : "invalid ",
+		    symbol_spec);
+      break;
+      
+    case G_TOKEN_ERROR:
+      print_unexp = FALSE;
+      expected_token = G_TOKEN_NONE;
+      switch (scanner->value.v_error)
+	{
+	case G_ERR_UNEXP_EOF:
+	  g_snprintf (token_string, token_string_len, "scanner: unexpected end of file");
+	  break;
+	  
+	case G_ERR_UNEXP_EOF_IN_STRING:
+	  g_snprintf (token_string, token_string_len, "scanner: unterminated string constant");
+	  break;
+	  
+	case G_ERR_UNEXP_EOF_IN_COMMENT:
+	  g_snprintf (token_string, token_string_len, "scanner: unterminated comment");
+	  break;
+	  
+	case G_ERR_NON_DIGIT_IN_CONST:
+	  g_snprintf (token_string, token_string_len, "scanner: non digit in constant");
+	  break;
+	  
+	case G_ERR_FLOAT_RADIX:
+	  g_snprintf (token_string, token_string_len, "scanner: invalid radix for floating constant");
+	  break;
+	  
+	case G_ERR_FLOAT_MALFORMED:
+	  g_snprintf (token_string, token_string_len, "scanner: malformed floating constant");
+	  break;
+	  
+	case G_ERR_DIGIT_RADIX:
+	  g_snprintf (token_string, token_string_len, "scanner: digit is beyond radix");
+	  break;
+	  
+	case G_ERR_UNKNOWN:
+	default:
+	  g_snprintf (token_string, token_string_len, "scanner: unknown error");
+	  break;
+	}
+      break;
+      
+    case G_TOKEN_CHAR:
+      g_snprintf (token_string, token_string_len, "character `%c'", scanner->value.v_char);
+      break;
+      
+    case G_TOKEN_IDENTIFIER:
+    case G_TOKEN_IDENTIFIER_NULL:
+      if (expected_token == G_TOKEN_IDENTIFIER ||
+	  expected_token == G_TOKEN_IDENTIFIER_NULL)
+	print_unexp = FALSE;
+      g_snprintf (token_string,
+		  token_string_len,
+		  "%s%s `%s'",
+		  print_unexp ? "" : "invalid ",
+		  identifier_spec,
+		  scanner->token == G_TOKEN_IDENTIFIER ? scanner->value.v_string : "null");
+      break;
+      
+    case G_TOKEN_BINARY:
+    case G_TOKEN_OCTAL:
+    case G_TOKEN_INT:
+    case G_TOKEN_HEX:
+      g_snprintf (token_string, token_string_len, "number `%ld'", scanner->value.v_int);
+      break;
+      
+    case G_TOKEN_FLOAT:
+      g_snprintf (token_string, token_string_len, "number `%.3f'", scanner->value.v_float);
+      break;
+      
+    case G_TOKEN_STRING:
+      if (expected_token == G_TOKEN_STRING)
+	print_unexp = FALSE;
+      g_snprintf (token_string,
+		  token_string_len,
+		  "%s%sstring constant \"%s\"",
+		  print_unexp ? "" : "invalid ",
+		  scanner->value.v_string[0] == 0 ? "empty " : "",
+		  scanner->value.v_string);
+      token_string[token_string_len - 2] = '"';
+      token_string[token_string_len - 1] = 0;
+      break;
+      
+    case G_TOKEN_COMMENT_SINGLE:
+    case G_TOKEN_COMMENT_MULTI:
+      g_snprintf (token_string, token_string_len, "comment");
+      break;
+      
+    case G_TOKEN_NONE:
+      /* somehow the user's parsing code is screwed, there isn't much
+       * we can do about it.
+       * Note, a common case to trigger this is
+       * g_scanner_peek_next_token(); g_scanner_unexp_token();
+       * without an intermediate g_scanner_get_next_token().
+       */
+      g_assert_not_reached ();
+      break;
+    }
+  
+  
+  switch (expected_token)
+    {
+      gboolean need_valid;
+      
+    default:
+      if (expected_token >= 1 && expected_token <= 255)
+	{
+	  if ((expected_token >= ' ' && expected_token <= '~') ||
+	      strchr (scanner->config->cset_identifier_first, expected_token) ||
+	      strchr (scanner->config->cset_identifier_nth, expected_token))
+	    g_snprintf (expected_string, expected_string_len, "character `%c'", expected_token);
+	  else
+	    g_snprintf (expected_string, expected_string_len, "character `\\%o'", expected_token);
+	  break;
+	}
+      else if (!scanner->config->symbol_2_token)
+	{
+	  g_snprintf (expected_string, expected_string_len, "(unknown) token <%d>", expected_token);
+	  break;
+	}
+      /* fall through */
+    case G_TOKEN_SYMBOL:
+      need_valid = (scanner->token == G_TOKEN_SYMBOL ||
+		    (scanner->config->symbol_2_token &&
+		     scanner->token > G_TOKEN_LAST));
+      g_snprintf (expected_string,
+		  expected_string_len,
+		  "%s%s",
+		  need_valid ? "valid " : "",
+		  symbol_spec);
+      /* FIXME: should we attempt to lookup the symbol_name for symbol_2_token? */
+      break;
+      
+    case G_TOKEN_INT:
+      g_snprintf (expected_string, expected_string_len, "%snumber (integer)",
+		  scanner->token == G_TOKEN_INT ? "valid " : "");
+      break;
+      
+    case G_TOKEN_FLOAT:
+      g_snprintf (expected_string, expected_string_len, "%snumber (float)",
+		  scanner->token == G_TOKEN_FLOAT ? "valid " : "");
+      break;
+      
+    case G_TOKEN_STRING:
+      g_snprintf (expected_string,
+		  expected_string_len,
+		  "%sstring constant",
+		  scanner->token == G_TOKEN_STRING ? "valid " : "");
+      break;
+      
+    case G_TOKEN_IDENTIFIER:
+    case G_TOKEN_IDENTIFIER_NULL:
+      g_snprintf (expected_string,
+		  expected_string_len,
+		  "%s%s",
+		  (scanner->token == G_TOKEN_IDENTIFIER_NULL ||
+		   scanner->token == G_TOKEN_IDENTIFIER ? "valid " : ""),
+		  identifier_spec);
+      break;
+      
+    case G_TOKEN_EOF:
+      g_snprintf (expected_string, expected_string_len, "end of file");
+      break;
+
+    case G_TOKEN_NONE:
+      break;
+    }
+  
+  if (message && message[0] != 0)
+    message_prefix = " - ";
+  else
+    {
+      message_prefix = "";
+      message = "";
+    }
+  
+  if (expected_token != G_TOKEN_NONE)
+    {
+      if (print_unexp)
+	msg_handler (scanner,
+		     "unexpected %s, expected %s%s%s",
+		     token_string,
+		     expected_string,
+		     message_prefix,
+		     message);
+      else
+	msg_handler (scanner,
+		     "%s, expected %s%s%s",
+		     token_string,
+		     expected_string,
+		     message_prefix,
+		     message);
+    }
+  else
+    {
+      if (print_unexp)
+	msg_handler (scanner,
+		     "unexpected %s%s%s",
+		     token_string,
+		     message_prefix,
+		     message);
+      else
+	msg_handler (scanner,
+		     "%s%s%s",
+		     token_string,
+		     message_prefix,
+		     message);
+    }
+  
+  g_free (token_string);
+  g_free (expected_string);
+}
+
+static void
+g_scanner_get_token_i (GScanner	*scanner,
+		       GTokenType	*token_p,
+		       GTokenValue	*value_p,
+		       guint		*line_p,
+		       guint		*position_p)
+{
+  do
+    {
+      g_scanner_free_value (token_p, value_p);
+      g_scanner_get_token_ll (scanner, token_p, value_p, line_p, position_p);
+    }
+  while (((*token_p > 0 && *token_p < 256) &&
+	  strchr (scanner->config->cset_skip_characters, *token_p)) ||
+	 (*token_p == G_TOKEN_CHAR &&
+	  strchr (scanner->config->cset_skip_characters, value_p->v_char)) ||
+	 (*token_p == G_TOKEN_COMMENT_MULTI &&
+	  scanner->config->skip_comment_multi) ||
+	 (*token_p == G_TOKEN_COMMENT_SINGLE &&
+	  scanner->config->skip_comment_single));
+  
+  switch (*token_p)
+    {
+    case G_TOKEN_IDENTIFIER:
+      if (scanner->config->identifier_2_string)
+	*token_p = G_TOKEN_STRING;
+      break;
+      
+    case G_TOKEN_SYMBOL:
+      if (scanner->config->symbol_2_token)
+	*token_p = (GTokenType) value_p->v_symbol;
+      break;
+      
+    case G_TOKEN_BINARY:
+    case G_TOKEN_OCTAL:
+    case G_TOKEN_HEX:
+      if (scanner->config->numbers_2_int)
+	*token_p = G_TOKEN_INT;
+      break;
+      
+    default:
+      break;
+    }
+  
+  if (*token_p == G_TOKEN_INT &&
+      scanner->config->int_2_float)
+    {
+      *token_p = G_TOKEN_FLOAT;
+      value_p->v_float = value_p->v_int;
+    }
+  
+  errno = 0;
+}
+
+static void
+g_scanner_get_token_ll	(GScanner	*scanner,
+			 GTokenType	*token_p,
+			 GTokenValue	*value_p,
+			 guint		*line_p,
+			 guint		*position_p)
+{
+  GScannerConfig *config;
+  GTokenType	   token;
+  gboolean	   in_comment_multi;
+  gboolean	   in_comment_single;
+  gboolean	   in_string_sq;
+  gboolean	   in_string_dq;
+  GString	  *gstring;
+  GTokenValue	   value;
+  guchar	   ch;
+  
+  config = scanner->config;
+  (*value_p).v_int = 0;
+  
+  if ((scanner->text >= scanner->text_end && scanner->input_fd < 0) ||
+      scanner->token == G_TOKEN_EOF)
+    {
+      *token_p = G_TOKEN_EOF;
+      return;
+    }
+  
+  in_comment_multi = FALSE;
+  in_comment_single = FALSE;
+  in_string_sq = FALSE;
+  in_string_dq = FALSE;
+  gstring = NULL;
+  
+  do /* while (ch != 0) */
+    {
+      gboolean dotted_float = FALSE;
+      
+      ch = g_scanner_get_char (scanner, line_p, position_p);
+      
+      value.v_int = 0;
+      token = G_TOKEN_NONE;
+      
+      /* this is *evil*, but needed ;(
+       * we first check for identifier first character, because	 it
+       * might interfere with other key chars like slashes or numbers
+       */
+      if (config->scan_identifier &&
+	  ch && strchr (config->cset_identifier_first, ch))
+	goto identifier_precedence;
+      
+      switch (ch)
+	{
+	case 0:
+	  token = G_TOKEN_EOF;
+	  (*position_p)++;
+	  /* ch = 0; */
+	  break;
+	  
+	case '/':
+	  if (!config->scan_comment_multi ||
+	      g_scanner_peek_next_char (scanner) != '*')
+	    goto default_case;
+	  g_scanner_get_char (scanner, line_p, position_p);
+	  token = G_TOKEN_COMMENT_MULTI;
+	  in_comment_multi = TRUE;
+	  gstring = g_string_new ("");
+	  while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0)
+	    {
+	      if (ch == '*' && g_scanner_peek_next_char (scanner) == '/')
+		{
+		  g_scanner_get_char (scanner, line_p, position_p);
+		  in_comment_multi = FALSE;
+		  break;
+		}
+	      else
+		g_string_append_c (gstring, ch);
+	    }
+	  ch = 0;
+	  break;
+	  
+	case '\'':
+	  if (!config->scan_string_sq)
+	    goto default_case;
+	  token = G_TOKEN_STRING;
+	  in_string_sq = TRUE;
+	  gstring = g_string_new ("");
+	  while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0)
+	    {
+	      if (ch == '\'')
+		{
+		  in_string_sq = FALSE;
+		  break;
+		}
+	      else
+		gstring = g_string_append_c (gstring, ch);
+	    }
+	  ch = 0;
+	  break;
+	  
+	case '"':
+	  if (!config->scan_string_dq)
+	    goto default_case;
+	  token = G_TOKEN_STRING;
+	  in_string_dq = TRUE;
+	  gstring = g_string_new ("");
+	  while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0)
+	    {
+	      if (ch == '"')
+		{
+		  in_string_dq = FALSE;
+		  break;
+		}
+	      else
+		{
+		  if (ch == '\\')
+		    {
+		      ch = g_scanner_get_char (scanner, line_p, position_p);
+		      switch (ch)
+			{
+			  guint	i;
+			  guint	fchar;
+			  
+			case 0:
+			  break;
+			  
+			case '\\':
+			  gstring = g_string_append_c (gstring, '\\');
+			  break;
+			  
+			case 'n':
+			  gstring = g_string_append_c (gstring, '\n');
+			  break;
+			  
+			case 't':
+			  gstring = g_string_append_c (gstring, '\t');
+			  break;
+			  
+			case 'r':
+			  gstring = g_string_append_c (gstring, '\r');
+			  break;
+			  
+			case 'b':
+			  gstring = g_string_append_c (gstring, '\b');
+			  break;
+			  
+			case 'f':
+			  gstring = g_string_append_c (gstring, '\f');
+			  break;
+			  
+			case '0':
+			case '1':
+			case '2':
+			case '3':
+			case '4':
+			case '5':
+			case '6':
+			case '7':
+			  i = ch - '0';
+			  fchar = g_scanner_peek_next_char (scanner);
+			  if (fchar >= '0' && fchar <= '7')
+			    {
+			      ch = g_scanner_get_char (scanner, line_p, position_p);
+			      i = i * 8 + ch - '0';
+			      fchar = g_scanner_peek_next_char (scanner);
+			      if (fchar >= '0' && fchar <= '7')
+				{
+				  ch = g_scanner_get_char (scanner, line_p, position_p);
+				  i = i * 8 + ch - '0';
+				}
+			    }
+			  gstring = g_string_append_c (gstring, i);
+			  break;
+			  
+			default:
+			  gstring = g_string_append_c (gstring, ch);
+			  break;
+			}
+		    }
+		  else
+		    gstring = g_string_append_c (gstring, ch);
+		}
+	    }
+	  ch = 0;
+	  break;
+	  
+	case '.':
+	  if (!config->scan_float)
+	    goto default_case;
+	  token = G_TOKEN_FLOAT;
+	  dotted_float = TRUE;
+	  ch = g_scanner_get_char (scanner, line_p, position_p);
+	  goto number_parsing;
+	  
+	case '$':
+	  if (!config->scan_hex_dollar)
+	    goto default_case;
+	  token = G_TOKEN_HEX;
+	  ch = g_scanner_get_char (scanner, line_p, position_p);
+	  goto number_parsing;
+	  
+	case '0':
+	  if (config->scan_octal)
+	    token = G_TOKEN_OCTAL;
+	  else
+	    token = G_TOKEN_INT;
+	  ch = g_scanner_peek_next_char (scanner);
+	  if (config->scan_hex && (ch == 'x' || ch == 'X'))
+	    {
+	      token = G_TOKEN_HEX;
+	      g_scanner_get_char (scanner, line_p, position_p);
+	      ch = g_scanner_get_char (scanner, line_p, position_p);
+	      if (ch == 0)
+		{
+		  token = G_TOKEN_ERROR;
+		  value.v_error = G_ERR_UNEXP_EOF;
+		  (*position_p)++;
+		  break;
+		}
+	      if (g_scanner_char_2_num (ch, 16) < 0)
+		{
+		  token = G_TOKEN_ERROR;
+		  value.v_error = G_ERR_DIGIT_RADIX;
+		  ch = 0;
+		  break;
+		}
+	    }
+	  else if (config->scan_binary && (ch == 'b' || ch == 'B'))
+	    {
+	      token = G_TOKEN_BINARY;
+	      g_scanner_get_char (scanner, line_p, position_p);
+	      ch = g_scanner_get_char (scanner, line_p, position_p);
+	      if (ch == 0)
+		{
+		  token = G_TOKEN_ERROR;
+		  value.v_error = G_ERR_UNEXP_EOF;
+		  (*position_p)++;
+		  break;
+		}
+	      if (g_scanner_char_2_num (ch, 10) < 0)
+		{
+		  token = G_TOKEN_ERROR;
+		  value.v_error = G_ERR_NON_DIGIT_IN_CONST;
+		  ch = 0;
+		  break;
+		}
+	    }
+	  else
+	    ch = '0';
+	  /* fall through */
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	number_parsing:
+	{
+          gboolean in_number = TRUE;
+	  gchar *endptr;
+	  
+	  if (token == G_TOKEN_NONE)
+	    token = G_TOKEN_INT;
+	  
+	  gstring = g_string_new (dotted_float ? "0." : "");
+	  gstring = g_string_append_c (gstring, ch);
+	  
+	  do /* while (in_number) */
+	    {
+	      gboolean is_E;
+	      
+	      is_E = token == G_TOKEN_FLOAT && (ch == 'e' || ch == 'E');
+	      
+	      ch = g_scanner_peek_next_char (scanner);
+	      
+	      if (g_scanner_char_2_num (ch, 36) >= 0 ||
+		  (config->scan_float && ch == '.') ||
+		  (is_E && (ch == '+' || ch == '-')))
+		{
+		  ch = g_scanner_get_char (scanner, line_p, position_p);
+		  
+		  switch (ch)
+		    {
+		    case '.':
+		      if (token != G_TOKEN_INT && token != G_TOKEN_OCTAL)
+			{
+			  value.v_error = token == G_TOKEN_FLOAT ? G_ERR_FLOAT_MALFORMED : G_ERR_FLOAT_RADIX;
+			  token = G_TOKEN_ERROR;
+			  in_number = FALSE;
+			}
+		      else
+			{
+			  token = G_TOKEN_FLOAT;
+			  gstring = g_string_append_c (gstring, ch);
+			}
+		      break;
+		      
+		    case '0':
+		    case '1':
+		    case '2':
+		    case '3':
+		    case '4':
+		    case '5':
+		    case '6':
+		    case '7':
+		    case '8':
+		    case '9':
+		      gstring = g_string_append_c (gstring, ch);
+		      break;
+		      
+		    case '-':
+		    case '+':
+		      if (token != G_TOKEN_FLOAT)
+			{
+			  token = G_TOKEN_ERROR;
+			  value.v_error = G_ERR_NON_DIGIT_IN_CONST;
+			  in_number = FALSE;
+			}
+		      else
+			gstring = g_string_append_c (gstring, ch);
+		      break;
+		      
+		    case 'e':
+		    case 'E':
+		      if ((token != G_TOKEN_HEX && !config->scan_float) ||
+			  (token != G_TOKEN_HEX &&
+			   token != G_TOKEN_OCTAL &&
+			   token != G_TOKEN_FLOAT &&
+			   token != G_TOKEN_INT))
+			{
+			  token = G_TOKEN_ERROR;
+			  value.v_error = G_ERR_NON_DIGIT_IN_CONST;
+			  in_number = FALSE;
+			}
+		      else
+			{
+			  if (token != G_TOKEN_HEX)
+			    token = G_TOKEN_FLOAT;
+			  gstring = g_string_append_c (gstring, ch);
+			}
+		      break;
+		      
+		    default:
+		      if (token != G_TOKEN_HEX)
+			{
+			  token = G_TOKEN_ERROR;
+			  value.v_error = G_ERR_NON_DIGIT_IN_CONST;
+			  in_number = FALSE;
+			}
+		      else
+			gstring = g_string_append_c (gstring, ch);
+		      break;
+		    }
+		}
+	      else
+		in_number = FALSE;
+	    }
+	  while (in_number);
+	  
+	  endptr = NULL;
+	  switch (token)
+	    {
+	    case G_TOKEN_BINARY:
+	      value.v_binary = strtol (gstring->str, &endptr, 2);
+	      break;
+	      
+	    case G_TOKEN_OCTAL:
+	      value.v_octal = strtol (gstring->str, &endptr, 8);
+	      break;
+	      
+	    case G_TOKEN_INT:
+	      value.v_int = strtol (gstring->str, &endptr, 10);
+	      break;
+	      
+	    case G_TOKEN_FLOAT:
+	      value.v_float = g_strtod (gstring->str, &endptr);
+	      break;
+	      
+	    case G_TOKEN_HEX:
+	      value.v_hex = strtol (gstring->str, &endptr, 16);
+	      break;
+	      
+	    default:
+	      break;
+	    }
+	  if (endptr && *endptr)
+	    {
+	      token = G_TOKEN_ERROR;
+	      if (*endptr == 'e' || *endptr == 'E')
+		value.v_error = G_ERR_NON_DIGIT_IN_CONST;
+	      else
+		value.v_error = G_ERR_DIGIT_RADIX;
+	    }
+	  g_string_free (gstring, TRUE);
+	  gstring = NULL;
+	  ch = 0;
+	} /* number_parsing:... */
+	break;
+	
+	default:
+	default_case:
+	{
+	  if (config->cpair_comment_single &&
+	      ch == config->cpair_comment_single[0])
+	    {
+	      token = G_TOKEN_COMMENT_SINGLE;
+	      in_comment_single = TRUE;
+	      gstring = g_string_new ("");
+	      ch = g_scanner_get_char (scanner, line_p, position_p);
+	      while (ch != 0)
+		{
+		  if (ch == config->cpair_comment_single[1])
+		    {
+		      in_comment_single = FALSE;
+		      ch = 0;
+		      break;
+		    }
+		  
+		  gstring = g_string_append_c (gstring, ch);
+		  ch = g_scanner_get_char (scanner, line_p, position_p);
+		}
+	    }
+	  else if (config->scan_identifier && ch &&
+		   strchr (config->cset_identifier_first, ch))
+	    {
+	    identifier_precedence:
+	      
+	      if (config->cset_identifier_nth && ch &&
+		  strchr (config->cset_identifier_nth,
+			  g_scanner_peek_next_char (scanner)))
+		{
+		  token = G_TOKEN_IDENTIFIER;
+		  gstring = g_string_new ("");
+		  gstring = g_string_append_c (gstring, ch);
+		  do
+		    {
+		      ch = g_scanner_get_char (scanner, line_p, position_p);
+		      gstring = g_string_append_c (gstring, ch);
+		      ch = g_scanner_peek_next_char (scanner);
+		    }
+		  while (ch && strchr (config->cset_identifier_nth, ch));
+		  ch = 0;
+		}
+	      else if (config->scan_identifier_1char)
+		{
+		  token = G_TOKEN_IDENTIFIER;
+		  value.v_identifier = g_new0 (gchar, 2);
+		  value.v_identifier[0] = ch;
+		  ch = 0;
+		}
+	    }
+	  if (ch)
+	    {
+	      if (config->char_2_token)
+		token = ch;
+	      else
+		{
+		  token = G_TOKEN_CHAR;
+		  value.v_char = ch;
+		}
+	      ch = 0;
+	    }
+	} /* default_case:... */
+	break;
+	}
+      g_assert (ch == 0 && token != G_TOKEN_NONE); /* paranoid */
+    }
+  while (ch != 0);
+  
+  if (in_comment_multi || in_comment_single ||
+      in_string_sq || in_string_dq)
+    {
+      token = G_TOKEN_ERROR;
+      if (gstring)
+	{
+	  g_string_free (gstring, TRUE);
+	  gstring = NULL;
+	}
+      (*position_p)++;
+      if (in_comment_multi || in_comment_single)
+	value.v_error = G_ERR_UNEXP_EOF_IN_COMMENT;
+      else /* (in_string_sq || in_string_dq) */
+	value.v_error = G_ERR_UNEXP_EOF_IN_STRING;
+    }
+  
+  if (gstring)
+    {
+      value.v_string = gstring->str;
+      g_string_free (gstring, FALSE);
+      gstring = NULL;
+    }
+  
+  if (token == G_TOKEN_IDENTIFIER)
+    {
+      if (config->scan_symbols)
+	{
+	  GScannerKey *key;
+	  guint scope_id;
+	  
+	  scope_id = scanner->scope_id;
+	  key = g_scanner_lookup_internal (scanner, scope_id, value.v_identifier);
+	  if (!key && scope_id && scanner->config->scope_0_fallback)
+	    key = g_scanner_lookup_internal (scanner, 0, value.v_identifier);
+	  
+	  if (key)
+	    {
+	      g_free (value.v_identifier);
+	      token = G_TOKEN_SYMBOL;
+	      value.v_symbol = key->value;
+	    }
+	}
+      
+      if (token == G_TOKEN_IDENTIFIER &&
+	  config->scan_identifier_NULL &&
+	  strlen (value.v_identifier) == 4)
+	{
+	  const gchar *null_upper = "NULL";
+	  const gchar *null_lower = "null";
+	  
+	  if (scanner->config->case_sensitive)
+	    {
+	      if (value.v_identifier[0] == null_upper[0] &&
+		  value.v_identifier[1] == null_upper[1] &&
+		  value.v_identifier[2] == null_upper[2] &&
+		  value.v_identifier[3] == null_upper[3])
+		token = G_TOKEN_IDENTIFIER_NULL;
+	    }
+	  else
+	    {
+	      if ((value.v_identifier[0] == null_upper[0] ||
+		   value.v_identifier[0] == null_lower[0]) &&
+		  (value.v_identifier[1] == null_upper[1] ||
+		   value.v_identifier[1] == null_lower[1]) &&
+		  (value.v_identifier[2] == null_upper[2] ||
+		   value.v_identifier[2] == null_lower[2]) &&
+		  (value.v_identifier[3] == null_upper[3] ||
+		   value.v_identifier[3] == null_lower[3]))
+		token = G_TOKEN_IDENTIFIER_NULL;
+	    }
+	}
+    }
+  
+  *token_p = token;
+  *value_p = value;
+}
+
+
+
+
+gdouble
+g_strtod (const gchar *nptr,
+	  gchar **endptr)
+{
+  gchar *fail_pos_1;
+  gchar *fail_pos_2;
+  gdouble val_1;
+  gdouble val_2 = 0;
+
+  g_return_val_if_fail (nptr != NULL, 0);
+
+  fail_pos_1 = NULL;
+  fail_pos_2 = NULL;
+
+  val_1 = strtod (nptr, &fail_pos_1);
+
+  if (fail_pos_1 && fail_pos_1[0] != 0)
+    {
+      gchar *old_locale;
+
+      old_locale = g_strdup (setlocale (LC_NUMERIC, NULL));
+      setlocale (LC_NUMERIC, "C");
+      val_2 = strtod (nptr, &fail_pos_2);
+      setlocale (LC_NUMERIC, old_locale);
+      g_free (old_locale);
+    }
+
+  if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2)
+    {
+      if (endptr)
+	*endptr = fail_pos_1;
+      return val_1;
+    }
+  else
+    {
+      if (endptr)
+	*endptr = fail_pos_2;
+      return val_2;
+    }
+}
+
+
+#ifndef MB_LEN_MAX
+#  define MB_LEN_MAX 8
+#endif
+
+typedef struct
+{
+  guint min_width;
+  guint precision;
+  gboolean alternate_format, zero_padding, adjust_left, locale_grouping;
+  gboolean add_space, add_sign, possible_sign, seen_precision;
+  gboolean mod_half, mod_long, mod_extra_long;
+} PrintfArgSpec;
+
+
+static gsize
+printf_string_upper_bound (const gchar *format,
+			   gboolean     may_warn,
+			   va_list      args)
+{
+  static  gboolean honour_longs = sizeof(long) > 4 || sizeof(void*) > 4;
+  gsize len = 1;
+
+  if (!format)
+    return len;
+
+  while (*format)
+    {
+      register gchar c = *format++;
+
+      if (c != '%')
+	len += 1;
+      else /* (c == '%') */
+	{
+	  PrintfArgSpec spec = { 0, };
+	  gboolean seen_l = FALSE, conv_done = FALSE;
+	  gsize conv_len = 0;
+	  const gchar *spec_start = format;
+
+	  do
+	    {
+	      c = *format++;
+	      switch (c)
+		{
+		  GDoubleIEEE754 u_double;
+		  guint v_uint;
+		  gint v_int;
+		  const gchar *v_string;
+
+		  /* beware of positional parameters
+		   */
+		case '$':
+		  if (may_warn)
+		    g_warning (G_STRLOC ": unable to handle positional parameters (%%n$)");
+		  len += 1024; /* try adding some safety padding */
+		  break;
+
+		  /* parse flags
+		   */
+		case '#':
+		  spec.alternate_format = TRUE;
+		  break;
+		case '0':
+		  spec.zero_padding = TRUE;
+		  break;
+		case '-':
+		  spec.adjust_left = TRUE;
+		  break;
+		case ' ':
+		  spec.add_space = TRUE;
+		  break;
+		case '+':
+		  spec.add_sign = TRUE;
+		  break;
+		case '\'':
+		  spec.locale_grouping = TRUE;
+		  break;
+
+		  /* parse output size specifications
+		   */
+		case '.':
+		  spec.seen_precision = TRUE;
+		  break;
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+		  v_uint = c - '0';
+		  c = *format;
+		  while (c >= '0' && c <= '9')
+		    {
+		      format++;
+		      v_uint = v_uint * 10 + c - '0';
+		      c = *format;
+		    }
+		  if (spec.seen_precision)
+		    spec.precision = MAX (spec.precision, v_uint);
+		  else
+		    spec.min_width = MAX (spec.min_width, v_uint);
+		  break;
+		case '*':
+		  v_int = va_arg (args, int);
+		  if (spec.seen_precision)
+		    {
+		      /* forget about negative precision */
+		      if (v_int >= 0)
+			spec.precision = MAX (spec.precision, v_int);
+		    }
+		  else
+		    {
+		      if (v_int < 0)
+			{
+			  v_int = - v_int;
+			  spec.adjust_left = TRUE;
+			}
+		      spec.min_width = MAX (spec.min_width, v_int);
+		    }
+		  break;
+
+		  /* parse type modifiers
+		   */
+		case 'h':
+		  spec.mod_half = TRUE;
+		  break;
+		case 'l':
+		  if (!seen_l)
+		    {
+		      spec.mod_long = TRUE;
+		      seen_l = TRUE;
+		      break;
+		    }
+		  /* else, fall through */
+		case 'L':
+		case 'q':
+		  spec.mod_long = TRUE;
+		  spec.mod_extra_long = TRUE;
+		  break;
+		case 'z':
+		case 'Z':
+		  if (sizeof(size_t))
+		    {
+		      spec.mod_long = TRUE;
+		      spec.mod_extra_long = TRUE;
+		    }
+		  break;
+		case 't':
+		  if (sizeof(ptrdiff_t) > 4)
+		    {
+		      spec.mod_long = TRUE;
+		      spec.mod_extra_long = TRUE;
+		    }
+		  break;
+		case 'j':
+		  if (GLIB_SIZEOF_INTMAX > 4)
+		    {
+		      spec.mod_long = TRUE;
+		      spec.mod_extra_long = TRUE;
+		    }
+		  break;
+
+		  /* parse output conversions
+		   */
+		case '%':
+		  conv_len += 1;
+		  break;
+		case 'O':
+		case 'D':
+		case 'I':
+		case 'U':
+		  /* some C libraries feature long variants for these as well? */
+		  spec.mod_long = TRUE;
+		  /* fall through */
+		case 'o':
+		  conv_len += 2;
+		  /* fall through */
+		case 'd':
+		case 'i':
+		  conv_len += 1; /* sign */
+		  /* fall through */
+		case 'u':
+		  conv_len += 4;
+		  /* fall through */
+		case 'x':
+		case 'X':
+		  spec.possible_sign = TRUE;
+		  conv_len += 10;
+		  if (spec.mod_long && honour_longs)
+		    conv_len *= 2;
+		  if (spec.mod_extra_long)
+		    conv_len *= 2;
+		  if (spec.mod_extra_long)
+		    {
+		      (void) va_arg (args, gint64);
+		    }
+		  else if (spec.mod_long)
+		    (void) va_arg (args, long);
+		  else
+		    (void) va_arg (args, int);
+		  break;
+		case 'A':
+		case 'a':
+		  /*          0x */
+		  conv_len += 2;
+		  /* fall through */
+		case 'g':
+		case 'G':
+		case 'e':
+		case 'E':
+		case 'f':
+		  spec.possible_sign = TRUE;
+		  /*          n   .   dddddddddddddddddddddddd   E   +-  eeee */
+		  conv_len += 1 + 1 + MAX (24, spec.precision) + 1 + 1 + 4;
+                  if (may_warn && spec.mod_extra_long)
+		    g_warning (G_STRLOC ": unable to handle long double, collecting double only");
+#ifdef HAVE_LONG_DOUBLE
+#error need to implement special handling for long double
+#endif
+		  u_double.v_double = va_arg (args, double);
+		  /* %f can expand up to all significant digits before '.' (308) */
+		  if (c == 'f' &&
+		      u_double.mpn.biased_exponent > 0 && u_double.mpn.biased_exponent < 2047)
+		    {
+		      gint exp = u_double.mpn.biased_exponent;
+
+		      exp -= G_IEEE754_DOUBLE_BIAS;
+		      exp = exp * G_LOG_2_BASE_10 + 1;
+		      conv_len += ABS (exp);	/* exp can be <0 */
+		    }
+		  /* some printf() implementations require extra padding for rounding */
+		  conv_len += 2;
+		  /* we can't really handle locale specific grouping here */
+		  if (spec.locale_grouping)
+		    conv_len *= 2;
+		  break;
+		case 'C':
+		  spec.mod_long = TRUE;
+                  /* fall through */
+		case 'c':
+		  conv_len += spec.mod_long ? MB_LEN_MAX : 1;
+		  (void) va_arg (args, int);
+		  break;
+		case 'S':
+		  spec.mod_long = TRUE;
+		  /* fall through */
+		case 's':
+		  v_string = va_arg (args, char*);
+		  if (!v_string)
+		    conv_len += 8; /* hold "(null)" */
+		  else if (spec.seen_precision)
+		    conv_len += spec.precision;
+		  else
+		    conv_len += strlen (v_string);
+		  conv_done = TRUE;
+		  if (spec.mod_long)
+		    {
+		      if (may_warn)
+			g_warning (G_STRLOC": unable to handle wide char strings");
+		      len += 1024; /* try adding some safety padding */
+		    }
+		  break;
+		case 'P': /* do we actually need this? */
+		  /* fall through */
+		case 'p':
+		  spec.alternate_format = TRUE;
+		  conv_len += 10;
+		  if (honour_longs)
+		    conv_len *= 2;
+		  /* fall through */
+		case 'n':
+		  conv_done = TRUE;
+		  (void) va_arg (args, void*);
+		  break;
+		case 'm':
+		  /* there's not much we can do to be clever */
+		  v_string = g_strerror (errno);
+		  v_uint = v_string ? strlen (v_string) : 0;
+		  conv_len += MAX (256, v_uint);
+		  break;
+
+		  /* handle invalid cases
+		   */
+		case '\000':
+		  /* no conversion specification, bad bad */
+		  conv_len += format - spec_start;
+		  break;
+		default:
+		  if (may_warn)
+		    g_warning (G_STRLOC": unable to handle `%c' while parsing format",
+			       c);
+		  break;
+		}
+	      conv_done |= conv_len > 0;
+	    }
+	  while (!conv_done);
+	  /* handle width specifications */
+	  conv_len = MAX (conv_len, MAX (spec.precision, spec.min_width));
+	  /* handle flags */
+	  conv_len += spec.alternate_format ? 2 : 0;
+	  conv_len += (spec.add_space || spec.add_sign || spec.possible_sign);
+	  /* finally done */
+	  len += conv_len;
+	} /* else (c == '%') */
+    } /* while (*format) */
+
+  return len;
+}
+
+
+
+gsize
+g_printf_string_upper_bound (const gchar *format,
+			     va_list      args)
+{
+  return printf_string_upper_bound (format, TRUE, args);
+}
+
+gchar*
+g_get_current_dir (void)
+{
+  gchar *buffer = NULL;
+  gchar *dir = NULL;
+  static gulong max_len = 0;
+
+  if (max_len == 0) 
+    max_len = (G_PATH_LENGTH == -1) ? 2048 : G_PATH_LENGTH;
+  
+  /* We don't use getcwd(3) on SUNOS, because, it does a popen("pwd")
+   * and, if that wasn't bad enough, hangs in doing so.
+   */
+#if	(defined (sun) && !defined (__SVR4)) || !defined(HAVE_GETCWD)
+  buffer = g_new (gchar, max_len + 1);
+  *buffer = 0;
+  dir = getwd (buffer);
+#else	/* !sun || !HAVE_GETCWD */
+  while (max_len < G_MAXULONG / 2)
+    {
+      buffer = g_new (gchar, max_len + 1);
+      *buffer = 0;
+      dir = getcwd (buffer, max_len);
+
+      if (dir || errno != ERANGE)
+	break;
+
+      g_free (buffer);
+      max_len *= 2;
+    }
+#endif	/* !sun || !HAVE_GETCWD */
+  
+  if (!dir || !*buffer)
+    {
+      /* hm, should we g_error() out here?
+       * this can happen if e.g. "./" has mode \0000
+       */
+      buffer[0] = G_DIR_SEPARATOR;
+      buffer[1] = 0;
+    }
+
+  dir = g_strdup (buffer);
+  g_free (buffer);
+  
+  return dir;
+}
+
+gboolean
+g_path_is_absolute (const gchar *file_name)
+{
+  g_return_val_if_fail (file_name != NULL, FALSE);
+  
+  if (file_name[0] == G_DIR_SEPARATOR
+#ifdef G_OS_WIN32
+      || file_name[0] == '/'
+#endif
+				     )
+    return TRUE;
+
+#ifdef G_OS_WIN32
+  /* Recognize drive letter on native Windows */
+  if (g_ascii_isalpha (file_name[0]) && file_name[1] == ':' && (file_name[2] == G_DIR_SEPARATOR || file_name[2] == '/'))
+    return TRUE;
+#endif /* G_OS_WIN32 */
+
+  return FALSE;
+}
+
+/* vim:set ts=8 sw=2 sts=2: */
diff --git a/flow/gsl/gslglib.h b/flow/gsl/gslglib.h
new file mode 100644
index 0000000..cd1f952
--- /dev/null
+++ b/flow/gsl/gslglib.h
@@ -0,0 +1,858 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Stefan Westerfeld and Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_GLIB_H__
+#define __GSL_GLIB_H__
+
+#ifndef G_LOG_DOMAIN
+#define G_LOG_DOMAIN "GSL"
+#endif
+
+
+#include <limits.h>
+#include <float.h>
+#include <stddef.h>
+#include <stdarg.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+/* for -ansi -pedantic */
+#ifdef __GNUC__
+#define asm __asm__
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define	GSL_ASSERT(foo)		do { if (!(foo)) g_error ("assertion failed `%s'", #foo); } while (0)
+
+/* --- GLib typedefs --- */
+typedef void*		gpointer;
+typedef const void*	gconstpointer;
+typedef char		gchar;
+typedef unsigned char	guchar;
+typedef signed short	gshort;
+typedef unsigned short	gushort;
+typedef signed int	gint;
+typedef unsigned int	guint;
+typedef signed long	glong;
+typedef unsigned long	gulong;
+typedef float		gfloat;
+typedef double		gdouble;
+typedef size_t		gsize;
+typedef gchar		gint8;
+typedef guchar		guint8;
+typedef gshort		gint16;
+typedef gushort		guint16;
+typedef gint		gint32;
+typedef guint		guint32;
+typedef gint		gboolean;
+typedef gint32		GTime;
+#ifdef __alpha
+typedef long int		gint64;
+typedef unsigned long int	guint64;
+#else
+typedef long long int	gint64;
+typedef unsigned long long int  guint64;
+#endif
+typedef struct _GString GString;
+typedef struct _GDebugKey       GDebugKey;
+struct _GDebugKey
+{
+  const gchar *key;
+  guint  value;
+};
+typedef struct _GTimeVal        GTimeVal;
+struct _GTimeVal
+{
+  glong tv_sec;
+  glong tv_usec;
+};
+typedef gint            (*GCompareFunc)         (gconstpointer  a,
+                                                 gconstpointer  b);
+
+
+/* --- standard macros --- */
+#ifndef ABS
+#define ABS(a)		((a) > 0 ? (a) : -(a))
+#endif
+#ifndef MAX
+#define MAX(a,b)        ((a) > (b) ? (a) : (b))
+#endif
+#ifndef MIN
+#define MIN(a,b)        ((a) < (b) ? (a) : (b))
+#endif
+#ifndef CLAMP
+#define CLAMP(v,l,h)    ((v) < (l) ? (l) : (v) > (h) ? (h) : (v))
+#endif
+#ifndef FALSE
+#define FALSE           0
+#endif
+#ifndef TRUE
+#define TRUE            (!FALSE)
+#endif
+#ifndef NULL
+#define NULL            ((void*) 0)
+#endif
+
+
+/* --- glib macros --- */
+#define G_MINFLOAT      FLT_MIN
+#define G_MAXFLOAT      FLT_MAX
+#define G_MINDOUBLE     DBL_MIN
+#define G_MAXDOUBLE     DBL_MAX
+#define G_MINSHORT      SHRT_MIN
+#define G_MAXSHORT      SHRT_MAX
+#define G_MAXUSHORT     USHRT_MAX
+#define G_MININT        INT_MIN
+#define G_MININT64      ((gint64)  0x8000000000000000)
+#define G_MAXINT        INT_MAX
+#define G_MAXINT64      ((gint64)  0x7fffffffffffffff)
+#define G_MAXUINT       UINT_MAX
+#define G_MAXUINT64     ((guint64) 0xffffffffffffffff)
+#define G_MINLONG       LONG_MIN
+#define G_MAXLONG       LONG_MAX
+#define G_MAXULONG      ULONG_MAX
+#define	G_USEC_PER_SEC	1000000
+#define G_LITTLE_ENDIAN 1234
+#define G_BIG_ENDIAN    4321
+
+#define G_DIR_SEPARATOR '/'
+#ifdef	MAXPATHLEN
+#define	G_PATH_LENGTH	MAXPATHLEN
+#elif	defined (PATH_MAX)
+#define	G_PATH_LENGTH	PATH_MAX
+#elif   defined (_PC_PATH_MAX)
+#define	G_PATH_LENGTH	sysconf(_PC_PATH_MAX)
+#else
+#define G_PATH_LENGTH   2048
+#endif
+
+#define G_N_ELEMENTS(arr)          (sizeof (arr) / sizeof ((arr)[0]))
+#define G_STRINGIFY(macro_or_string)    G_STRINGIFY_ARG (macro_or_string)
+#define G_STRINGIFY_ARG(contents)       #contents
+#define G_STRLOC      __FILE__ ":" G_STRINGIFY (__LINE__)
+#if !(defined (G_STMT_START) && defined (G_STMT_END))
+#  if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus)
+#    define G_STMT_START        (void)(
+#    define G_STMT_END          )
+#  else
+#    if (defined (sun) || defined (__sun__))
+#      define G_STMT_START      if (1)
+#      define G_STMT_END        else (void)0
+#    else
+#      define G_STMT_START      do
+#      define G_STMT_END        while (0)
+#    endif
+#  endif
+#endif
+#define G_STRUCT_OFFSET(struct_type, member)    \
+    ((glong) ((guint8*) &((struct_type*) 0)->member))
+#define G_STRUCT_MEMBER_P(struct_p, struct_offset)   \
+    ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset)))
+#define G_STRUCT_MEMBER(member_type, struct_p, struct_offset)   \
+    (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset)))
+#define GINT_TO_POINTER(i)     ((gpointer) (int) (i))
+#define GUINT_TO_POINTER(i)     ((gpointer) (guint) (i))
+#define GPOINTER_TO_INT(p)     ((int) (p))
+#define GPOINTER_TO_UINT(p)    ((guint) (p))
+#define GUINT16_SWAP_LE_BE(val)        ((guint16) ( \
+    (((guint16) (val) & (guint16) 0x00ffU) << 8) | \
+    (((guint16) (val) & (guint16) 0xff00U) >> 8)))
+#define GUINT32_SWAP_LE_BE(val)        ((guint32) ( \
+    (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \
+    (((guint32) (val) & (guint32) 0x0000ff00U) <<  8) | \
+    (((guint32) (val) & (guint32) 0x00ff0000U) >>  8) | \
+    (((guint32) (val) & (guint32) 0xff000000U) >> 24)))
+
+#ifdef WORDS_BIGENDIAN
+#define GUINT16_TO_LE(val) GUINT16_SWAP_LE_BE(val)
+#define GUINT32_TO_LE(val) GUINT32_SWAP_LE_BE(val)
+#define GUINT16_TO_BE(val) ((guint16) (val))
+#define GUINT32_TO_BE(val) ((guint32) (val))
+#else /* LITTLEENDIAN */
+#define GUINT16_TO_LE(val) ((guint16) (val))
+#define GUINT32_TO_LE(val) ((guint32) (val))
+#define GUINT16_TO_BE(val) GUINT16_SWAP_LE_BE(val)
+#define GUINT32_TO_BE(val) GUINT32_SWAP_LE_BE(val)
+#endif
+
+#define GUINT16_FROM_LE(val)    (GUINT16_TO_LE (val))
+#define GUINT16_FROM_BE(val)    (GUINT16_TO_BE (val))
+#define GUINT32_FROM_LE(val)    (GUINT32_TO_LE (val))
+#define GUINT32_FROM_BE(val)    (GUINT32_TO_BE (val))
+
+
+#define g_memmove memmove
+#define g_assert  GSL_ASSERT
+#define g_assert_not_reached()	g_assert(!G_STRLOC": should not be reached")
+#define	g_return_if_fail(foo)		do { if (!(foo)) g_message (G_STRLOC ": assertion failed `%s'", #foo); } while (0)
+#define	g_return_val_if_fail(foo,v)		do { if (!(foo)) { g_message (G_STRLOC ": assertion failed `%s'", #foo); return(v);}} while (0)
+
+/* from galloca.h */
+
+#ifdef  __GNUC__
+/* GCC does the right thing */
+# undef alloca
+# define alloca(size)   __builtin_alloca (size)
+#elif defined (GLIB_HAVE_ALLOCA_H)
+/* a native and working alloca.h is there */
+# include <alloca.h>
+#else /* !__GNUC__ && !GLIB_HAVE_ALLOCA_H */
+# ifdef _MSC_VER
+#  include <malloc.h>
+#  define alloca _alloca
+# else /* !_MSC_VER */
+#  ifdef _AIX
+ #pragma alloca
+#  else /* !_AIX */
+#   ifndef alloca /* predefined by HP cc +Olibcalls */
+char *alloca ();
+#   endif /* !alloca */
+#  endif /* !_AIX */
+# endif /* !_MSC_VER */
+#endif /* !__GNUC__ && !GLIB_HAVE_ALLOCA_H */
+
+#define g_alloca(size) alloca (size)
+#define g_newa(struct_type, n_structs)  ((struct_type*) g_alloca (sizeof (struct_type) * (gsize) (n_structs)))
+
+/* needs inline configure check */
+#if defined (__xlc__)
+#  if !defined (inline)
+#    define inline _Inline
+#  endif
+#elif defined (__GNUC__)
+#define inline __inline__
+#else
+#define inline /* no inline */
+#endif
+
+
+/* --- inline functions --- */
+void
+gsl_g_log (const gchar*msg,const char *format, va_list ap);
+void
+gsl_g_print_fd (int fd,const char *format, va_list ap);
+static inline void
+g_error (const gchar *format,
+	 ...)
+{
+  va_list args;
+  va_start (args, format);
+  gsl_g_log ("**ERROR**", format, args);
+  va_end (args);
+}
+static inline void
+g_message (const gchar *format,
+	   ...)
+{
+  va_list args;
+  va_start (args, format);
+  gsl_g_log ("**MESSAGE**", format, args);
+  va_end (args);
+}
+static inline void
+g_critical (const gchar *format,
+	    ...)
+{
+  va_list args;
+  va_start (args, format);
+  gsl_g_log ("**CRITICAL**", format, args);
+  va_end (args);
+}
+static inline void
+g_warning (const gchar *format,
+	   ...)
+{
+  va_list args;
+  va_start (args, format);
+  gsl_g_log ("**WARNING**", format, args);
+  va_end (args);
+}
+static inline void
+g_print (const gchar *format,
+	 ...)
+{
+  va_list args;
+  va_start (args, format);
+  gsl_g_print_fd (1, format, args);
+  va_end (args);
+}
+static inline void
+g_printerr (const gchar *format,
+	    ...)
+{
+  va_list args;
+  va_start (args, format);
+  gsl_g_print_fd (2, format, args);
+  va_end (args);
+}
+typedef struct _GTrashStack     GTrashStack;
+struct _GTrashStack
+{
+  GTrashStack *next;
+};
+static inline  guint
+g_bit_storage (gulong number)
+{
+  register guint n_bits = 0;
+
+  do
+    {
+      n_bits++;
+      number >>= 1;
+    }
+  while (number);
+  return n_bits;
+}
+static inline void
+g_trash_stack_push (GTrashStack **stack_p,
+		    gpointer      data_p)
+{
+  GTrashStack *data = (GTrashStack *) data_p;
+
+  data->next = *stack_p;
+  *stack_p = data;
+}
+static inline gpointer
+g_trash_stack_pop (GTrashStack **stack_p)
+{
+  GTrashStack *data;
+
+  data = *stack_p;
+  if (data)
+    {
+      *stack_p = data->next;
+      /* NULLify private pointer here, most platforms store NULL as
+       * subsequent 0 bytes
+       */
+      data->next = NULL;
+    }
+
+  return data;
+}
+static inline gpointer
+g_trash_stack_peek (GTrashStack **stack_p)
+{
+  GTrashStack *data;
+
+  data = *stack_p;
+
+  return data;
+}
+static inline guint
+g_trash_stack_height (GTrashStack **stack_p)
+{
+  GTrashStack *data;
+  guint i = 0;
+
+  for (data = *stack_p; data; data = data->next)
+    i++;
+
+  return i;
+}
+
+
+/* --- GCC features --- */
+#if     __GNUC__ >= 2 && __GNUC_MINOR__ > 95
+#define G_GNUC_PRINTF( format_idx, arg_idx )    \
+  __attribute__((format (printf, format_idx, arg_idx)))
+#define G_GNUC_SCANF( format_idx, arg_idx )     \
+  __attribute__((format (scanf, format_idx, arg_idx)))
+#define G_GNUC_FORMAT( arg_idx )                \
+  __attribute__((format_arg (arg_idx)))
+#define G_GNUC_NORETURN                         \
+  __attribute__((noreturn))
+#define G_GNUC_CONST                            \
+  __attribute__((const))
+#define G_GNUC_UNUSED                           \
+  __attribute__((unused))
+#define G_GNUC_NO_INSTRUMENT                    \
+  __attribute__((no_instrument_function))
+#else   /* !__GNUC__ */
+#define G_GNUC_PRINTF( format_idx, arg_idx )
+#define G_GNUC_SCANF( format_idx, arg_idx )
+#define G_GNUC_FORMAT( arg_idx )
+#define G_GNUC_NORETURN
+#define G_GNUC_CONST
+#define G_GNUC_UNUSED
+#define G_GNUC_NO_INSTRUMENT
+#endif  /* !__GNUC__ */
+
+
+
+/* --- GPollFD (for poll(2)) --- */
+#define G_IO_IN      (0x0001 /* There is data to read */)
+#define G_IO_PRI     (0x0002 /* There is urgent data to read */)
+#define G_IO_OUT     (0x0004 /* Writing now will not block */)
+#define G_IO_ERR     (0x0008 /* Error condition */)
+#define G_IO_HUP     (0x0010 /* Hung up */)
+#define G_IO_NVAL    (0x0020 /* Invalid request: fd not open */)
+typedef struct
+{
+  gint    fd;
+  gushort events;
+  gushort revents;
+} GPollFD;
+
+
+
+/* --- functions --- */
+#define	g_malloc		gsl_g_malloc
+#define	g_malloc0		gsl_g_malloc0
+#define	g_realloc		gsl_g_realloc
+#define	g_free			gsl_g_free
+#define g_strdup		gsl_g_strdup
+#define g_strndup		gsl_g_strndup
+#define g_memdup		gsl_g_memdup
+#define	g_strdup_printf		gsl_g_strdup_printf
+#define	g_strdup_vprintf	gsl_g_strdup_vprintf
+#define	g_strndup		gsl_g_strndup
+#define	g_strconcat		gsl_g_strconcat
+#define	g_usleep		gsl_g_usleep
+#define	g_strerror		gsl_g_strerror
+#define	g_convert		gsl_g_convert
+#define g_direct_hash	 	gsl_g_direct_hash
+#define g_direct_equal 		gsl_g_direct_equal
+#define g_str_equal 		gsl_g_str_equal
+#define g_str_hash 		gsl_g_str_hash
+#define g_strtod		gsl_g_strtod
+#define g_stpcpy		gsl_g_stpcpy
+#define	g_strescape		gsl_g_strescape
+#define g_get_current_dir       gsl_g_get_current_dir
+#define g_path_is_absolute      gsl_g_path_is_absolute
+#define g_printf_string_upper_bound gsl_g_printf_string_upper_bound
+
+gpointer g_malloc         (gulong        n_bytes);
+gpointer g_malloc0        (gulong        n_bytes);
+gpointer g_realloc        (gpointer      mem,
+			   gulong        n_bytes);
+void     g_free           (gpointer      mem);
+gpointer              g_memdup         (gconstpointer mem,
+					guint          byte_size);
+gchar*                g_strdup         (const gchar *str);
+gchar*		      g_strndup (const gchar *str,
+				 gsize        n);
+gchar*                g_strdup_printf  (const gchar *format,
+					...) G_GNUC_PRINTF (1, 2);
+gchar*                g_strdup_vprintf (const gchar *format,
+					va_list      args);
+gchar*                g_strndup        (const gchar *str,
+					gsize        n);
+gchar*                g_strconcat      (const gchar *string1,
+					...); /* NULL terminated */
+gchar*		      g_convert	       (const gchar  *str,
+					gsize        len,            /* gssize */
+					const gchar  *to_codeset,
+					const gchar  *from_codeset,
+					gsize        *bytes_read,
+					gsize        *bytes_written,
+					void         **error);        /* GError */
+void g_usleep(unsigned long usec);
+char* g_strerror(int e);
+guint g_direct_hash (gconstpointer v);
+gboolean g_direct_equal (gconstpointer v1, gconstpointer v2);
+gboolean g_str_equal (gconstpointer v1,   gconstpointer v2);
+guint g_str_hash (gconstpointer key);
+gdouble	g_strtod (const gchar *nptr, 	  gchar **endptr);
+gsize g_printf_string_upper_bound (const gchar *format,  va_list      args);
+gchar * g_stpcpy (gchar       *dest, 	  const gchar *src);
+gchar * g_strescape (const gchar *source, const gchar *exceptions);
+gchar * g_get_current_dir (void);
+gboolean g_path_is_absolute (const gchar *file_name);
+
+
+
+/* --- function defines --- */
+#define g_new(struct_type, n_structs)           \
+    ((struct_type *) g_malloc (((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
+#define g_new0(struct_type, n_structs)          \
+    ((struct_type *) g_malloc0 (((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
+#define g_renew(struct_type, mem, n_structs)    \
+    ((struct_type *) g_realloc ((mem), ((gsize) sizeof (struct_type)) * ((gsize) (n_structs))))
+#define	g_try_malloc		malloc
+#define	g_try_realloc		realloc
+
+
+
+/* --- configure stuff!!! --- */
+#ifdef WORDS_BIGENDIAN
+#define G_BYTE_ORDER G_BIG_ENDIAN
+#else
+#define G_BYTE_ORDER G_LITTLE_ENDIAN
+#endif
+
+/* #define	GLIB_HAVE_STPCPY	1 */
+/* Define G_VA_COPY() to do the right thing for copying va_list variables.
+ * glibconfig.h may have already defined G_VA_COPY as va_copy or __va_copy.
+ */
+#if !defined (G_VA_COPY)
+#  if defined (__GNUC__) && ( defined (__PPC__) || defined (__s390__) ) && (defined (_CALL_SYSV) || defined (_WIN32) || defined (__s390__) )
+#    define G_VA_COPY(ap1, ap2)   (*(ap1) = *(ap2))
+#  elif defined (G_VA_COPY_AS_ARRAY)
+#    define G_VA_COPY(ap1, ap2)   g_memmove ((ap1), (ap2), sizeof (va_list))
+#  else /* va_list is a pointer */
+#    define G_VA_COPY(ap1, ap2)   ((ap1) = (ap2))
+#  endif /* va_list is a pointer */
+#endif /* !G_VA_COPY */
+
+
+
+
+/* subtract from biased_exponent to form base2 exponent (normal numbers) */
+typedef union  _GDoubleIEEE754  GDoubleIEEE754;
+typedef union  _GFloatIEEE754   GFloatIEEE754;
+#define G_IEEE754_FLOAT_BIAS    (127)
+#define G_IEEE754_DOUBLE_BIAS   (1023)
+/* multiply with base2 exponent to get base10 exponent (nomal numbers) */
+#define G_LOG_2_BASE_10         (0.30102999566398119521)
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+union _GFloatIEEE754
+{
+  gfloat v_float;
+  struct {
+    guint mantissa : 23;
+    guint biased_exponent : 8;
+    guint sign : 1;
+  } mpn;
+};
+union _GDoubleIEEE754
+{
+  gdouble v_double;
+  struct {
+    guint mantissa_low : 32;
+    guint mantissa_high : 20;
+    guint biased_exponent : 11;
+    guint sign : 1;
+  } mpn;
+};
+#elif G_BYTE_ORDER == G_BIG_ENDIAN
+union _GFloatIEEE754
+{
+  gfloat v_float;
+  struct {
+    guint sign : 1;
+    guint biased_exponent : 8;
+    guint mantissa : 23;
+  } mpn;
+};
+union _GDoubleIEEE754
+{
+  gdouble v_double;
+  struct {
+    guint sign : 1;
+    guint biased_exponent : 11;
+    guint mantissa_high : 20;
+    guint mantissa_low : 32;
+  } mpn;
+};
+#else /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */
+#error unknown ENDIAN type
+#endif /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */
+
+
+
+/* --- GHashTable --- */
+typedef struct _GHashTable  GHashTable;
+typedef gboolean  (*GHRFunc)  (gpointer  key,
+			       gpointer  value,
+			       gpointer  user_data);
+typedef void            (*GHFunc)               (gpointer       key,
+						 gpointer       value,
+						 gpointer       user_data);
+typedef guint           (*GHashFunc)            (gconstpointer  key);
+typedef gboolean        (*GEqualFunc)           (gconstpointer  a,
+						 gconstpointer  b);
+typedef void            (*GDestroyNotify)       (gpointer       data);
+#define g_hash_table_new               	gsl_g_hash_table_new
+#define g_hash_table_new_full          	gsl_g_hash_table_new_full
+#define g_hash_table_destroy           	gsl_g_hash_table_destroy
+#define g_hash_table_insert            	gsl_g_hash_table_insert
+#define g_hash_table_replace           	gsl_g_hash_table_replace
+#define g_hash_table_remove            	gsl_g_hash_table_remove
+#define g_hash_table_steal             	gsl_g_hash_table_steal
+#define g_hash_table_lookup            	gsl_g_hash_table_lookup
+#define g_hash_table_lookup_extended   	gsl_g_hash_table_lookup_extended
+#define g_hash_table_foreach           	gsl_g_hash_table_foreach
+#define g_hash_table_foreach_remove    	gsl_g_hash_table_foreach_remove
+#define g_hash_table_foreach_steal     	gsl_g_hash_table_foreach_steal
+#define g_hash_table_size              	gsl_g_hash_table_size
+GHashTable* g_hash_table_new               (GHashFunc       hash_func,
+					    GEqualFunc      key_equal_func);
+GHashTable* g_hash_table_new_full          (GHashFunc       hash_func,
+					    GEqualFunc      key_equal_func,
+					    GDestroyNotify  key_destroy_func,
+					    GDestroyNotify  value_destroy_func);
+void        g_hash_table_destroy           (GHashTable     *hash_table);
+void        g_hash_table_insert            (GHashTable     *hash_table,
+					    gpointer        key,
+					    gpointer        value);
+void        g_hash_table_replace           (GHashTable     *hash_table,
+					    gpointer        key,
+					    gpointer        value);
+gboolean    g_hash_table_remove            (GHashTable     *hash_table,
+					    gconstpointer   key);
+gboolean    g_hash_table_steal             (GHashTable     *hash_table,
+					    gconstpointer   key);
+gpointer    g_hash_table_lookup            (GHashTable     *hash_table,
+					    gconstpointer   key);
+gboolean    g_hash_table_lookup_extended   (GHashTable     *hash_table,
+					    gconstpointer   lookup_key,
+					    gpointer       *orig_key,
+					    gpointer       *value);
+void        g_hash_table_foreach           (GHashTable     *hash_table,
+					    GHFunc          func,
+					    gpointer        user_data);
+guint       g_hash_table_foreach_remove    (GHashTable     *hash_table,
+					    GHRFunc         func,
+					    gpointer        user_data);
+guint       g_hash_table_foreach_steal     (GHashTable     *hash_table,
+					    GHRFunc         func,
+					    gpointer        user_data);
+guint       g_hash_table_size              (GHashTable     *hash_table);
+
+
+/* --- GScanner --- */
+typedef struct _GScanner	GScanner;
+typedef struct _GScannerConfig	GScannerConfig;
+typedef union  _GTokenValue     GTokenValue;
+typedef void		(*GScannerMsgFunc)	(GScanner      *scanner,
+						 gchar	       *message,
+						 gint		error);
+#define G_CSET_A_2_Z	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+#define G_CSET_a_2_z	"abcdefghijklmnopqrstuvwxyz"
+#define G_CSET_DIGITS	"0123456789"
+#define G_CSET_LATINC	"\300\301\302\303\304\305\306"\
+			"\307\310\311\312\313\314\315\316\317\320"\
+			"\321\322\323\324\325\326"\
+			"\330\331\332\333\334\335\336"
+#define G_CSET_LATINS	"\337\340\341\342\343\344\345\346"\
+			"\347\350\351\352\353\354\355\356\357\360"\
+			"\361\362\363\364\365\366"\
+			"\370\371\372\373\374\375\376\377"
+typedef enum
+{
+  G_ERR_UNKNOWN,
+  G_ERR_UNEXP_EOF,
+  G_ERR_UNEXP_EOF_IN_STRING,
+  G_ERR_UNEXP_EOF_IN_COMMENT,
+  G_ERR_NON_DIGIT_IN_CONST,
+  G_ERR_DIGIT_RADIX,
+  G_ERR_FLOAT_RADIX,
+  G_ERR_FLOAT_MALFORMED
+} GErrorType;
+typedef enum
+{
+  G_TOKEN_EOF			=   0,
+
+  G_TOKEN_LEFT_PAREN		= '(',
+  G_TOKEN_RIGHT_PAREN		= ')',
+  G_TOKEN_LEFT_CURLY		= '{',
+  G_TOKEN_RIGHT_CURLY		= '}',
+  G_TOKEN_LEFT_BRACE		= '[',
+  G_TOKEN_RIGHT_BRACE		= ']',
+  G_TOKEN_EQUAL_SIGN		= '=',
+  G_TOKEN_COMMA			= ',',
+
+  G_TOKEN_NONE			= 256,
+
+  G_TOKEN_ERROR,
+
+  G_TOKEN_CHAR,
+  G_TOKEN_BINARY,
+  G_TOKEN_OCTAL,
+  G_TOKEN_INT,
+  G_TOKEN_HEX,
+  G_TOKEN_FLOAT,
+  G_TOKEN_STRING,
+
+  G_TOKEN_SYMBOL,
+  G_TOKEN_IDENTIFIER,
+  G_TOKEN_IDENTIFIER_NULL,
+
+  G_TOKEN_COMMENT_SINGLE,
+  G_TOKEN_COMMENT_MULTI,
+  G_TOKEN_LAST
+} GTokenType;
+union	_GTokenValue
+{
+  gpointer	v_symbol;
+  gchar		*v_identifier;
+  gulong	v_binary;
+  gulong	v_octal;
+  gulong	v_int;
+  gdouble	v_float;
+  gulong	v_hex;
+  gchar		*v_string;
+  gchar		*v_comment;
+  guchar	v_char;
+  guint		v_error;
+};
+struct	_GScannerConfig
+{
+  const gchar	*cset_skip_characters;		/* default: " \t\n" */
+  const gchar	*cset_identifier_first;
+  const gchar	*cset_identifier_nth;
+  const gchar	*cpair_comment_single;		/* default: "#\n" */
+  guint		case_sensitive : 1;
+  guint		skip_comment_multi : 1;		/* C like comment */
+  guint		skip_comment_single : 1;	/* single line comment */
+  guint		scan_comment_multi : 1;		/* scan multi line comments? */
+  guint		scan_identifier : 1;
+  guint		scan_identifier_1char : 1;
+  guint		scan_identifier_NULL : 1;
+  guint		scan_symbols : 1;
+  guint		scan_binary : 1;
+  guint		scan_octal : 1;
+  guint		scan_float : 1;
+  guint		scan_hex : 1;			/* `0x0ff0' */
+  guint		scan_hex_dollar : 1;		/* `$0ff0' */
+  guint		scan_string_sq : 1;		/* string: 'anything' */
+  guint		scan_string_dq : 1;		/* string: "\\-escapes!\n" */
+  guint		numbers_2_int : 1;		/* bin, octal, hex => int */
+  guint		int_2_float : 1;		/* int => G_TOKEN_FLOAT? */
+  guint		identifier_2_string : 1;
+  guint		char_2_token : 1;		/* return G_TOKEN_CHAR? */
+  guint		symbol_2_token : 1;
+  guint		scope_0_fallback : 1;		/* try scope 0 on lookups? */
+};
+struct	_GScanner
+{
+  gpointer		user_data;
+  guint			max_parse_errors;
+  guint			parse_errors;
+  const gchar		*input_name;
+  /* GData			*qdata; */
+  GScannerConfig	*config;
+  GTokenType		token;
+  GTokenValue		value;
+  guint			line;
+  guint			position;
+  GTokenType		next_token;
+  GTokenValue		next_value;
+  guint			next_line;
+  guint			next_position;
+  GHashTable		*symbol_table;
+  gint			input_fd;
+  const gchar		*text;
+  const gchar		*text_end;
+  gchar			*buffer;
+  guint			scope_id;
+  GScannerMsgFunc	msg_handler;
+};
+#define g_scanner_new			   gsl_g_scanner_new
+#define g_scanner_destroy		   gsl_g_scanner_destroy
+#define g_scanner_input_file		   gsl_g_scanner_input_file
+#define g_scanner_sync_file_offset	   gsl_g_scanner_sync_file_offset
+#define g_scanner_input_text		   gsl_g_scanner_input_text
+#define g_scanner_get_next_token	   gsl_g_scanner_get_next_token
+#define g_scanner_peek_next_token	   gsl_g_scanner_peek_next_token
+#define g_scanner_cur_token		   gsl_g_scanner_cur_token
+#define g_scanner_cur_value		   gsl_g_scanner_cur_value
+#define g_scanner_cur_line		   gsl_g_scanner_cur_line
+#define g_scanner_cur_position		   gsl_g_scanner_cur_position
+#define g_scanner_eof			   gsl_g_scanner_eof
+#define g_scanner_set_scope		   gsl_g_scanner_set_scope
+#define g_scanner_scope_add_symbol	   gsl_g_scanner_scope_add_symbol
+#define g_scanner_scope_remove_symbol	   gsl_g_scanner_scope_remove_symbol
+#define g_scanner_scope_lookup_symbol	   gsl_g_scanner_scope_lookup_symbol
+#define g_scanner_scope_foreach_symbol	   gsl_g_scanner_scope_foreach_symbol
+#define g_scanner_lookup_symbol		   gsl_g_scanner_lookup_symbol
+#define g_scanner_unexp_token		   gsl_g_scanner_unexp_token
+#define g_scanner_error			   gsl_g_scanner_error
+#define g_scanner_warn			   gsl_g_scanner_warn
+GScanner*	g_scanner_new			(const GScannerConfig *config_templ);
+void		g_scanner_destroy		(GScanner	*scanner);
+void		g_scanner_input_file		(GScanner	*scanner,
+						 gint		input_fd);
+void		g_scanner_sync_file_offset	(GScanner	*scanner);
+void		g_scanner_input_text		(GScanner	*scanner,
+						 const	gchar	*text,
+						 guint		text_len);
+GTokenType	g_scanner_get_next_token	(GScanner	*scanner);
+GTokenType	g_scanner_peek_next_token	(GScanner	*scanner);
+GTokenType	g_scanner_cur_token		(GScanner	*scanner);
+GTokenValue	g_scanner_cur_value		(GScanner	*scanner);
+guint		g_scanner_cur_line		(GScanner	*scanner);
+guint		g_scanner_cur_position		(GScanner	*scanner);
+gboolean	g_scanner_eof			(GScanner	*scanner);
+guint		g_scanner_set_scope		(GScanner	*scanner,
+						 guint		 scope_id);
+void		g_scanner_scope_add_symbol	(GScanner	*scanner,
+						 guint		 scope_id,
+						 const gchar	*symbol,
+						 gpointer	value);
+void		g_scanner_scope_remove_symbol	(GScanner	*scanner,
+						 guint		 scope_id,
+						 const gchar	*symbol);
+gpointer	g_scanner_scope_lookup_symbol	(GScanner	*scanner,
+						 guint		 scope_id,
+						 const gchar	*symbol);
+void		g_scanner_scope_foreach_symbol	(GScanner	*scanner,
+						 guint		 scope_id,
+						 GHFunc		 func,
+						 gpointer	 user_data);
+gpointer	g_scanner_lookup_symbol		(GScanner	*scanner,
+						 const gchar	*symbol);
+void		g_scanner_unexp_token		(GScanner	*scanner,
+						 GTokenType	expected_token,
+						 const gchar	*identifier_spec,
+						 const gchar	*symbol_spec,
+						 const gchar	*symbol_name,
+						 const gchar	*message,
+						 gint		 is_error);
+void		g_scanner_error			(GScanner	*scanner,
+						 const gchar	*format,
+						 ...) G_GNUC_PRINTF (2,3);
+void		g_scanner_warn			(GScanner	*scanner,
+						 const gchar	*format,
+						 ...) G_GNUC_PRINTF (2,3);
+#define		g_scanner_add_symbol( scanner, symbol, value )	G_STMT_START { \
+  g_scanner_scope_add_symbol ((scanner), 0, (symbol), (value)); \
+} G_STMT_END
+#define		g_scanner_remove_symbol( scanner, symbol )	G_STMT_START { \
+  g_scanner_scope_remove_symbol ((scanner), 0, (symbol)); \
+} G_STMT_END
+#define		g_scanner_foreach_symbol( scanner, func, data )	G_STMT_START { \
+  g_scanner_scope_foreach_symbol ((scanner), 0, (func), (data)); \
+} G_STMT_END
+
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#include <gsl/gslconfig.h>
+#if GSL_USE_ARTS_THREADS
+#include <gsl/gslartsthreads.h>
+#endif
+
+/* if inline is defined in C++ mode, it can cause a lot of grief with C++ */
+/* header files so we need to undefine it here again */
+
+#if defined(__cplusplus) && defined(inline)
+#undef inline
+#endif
+
+#endif /* __GSL_GLIB_H__ */ /* vim: set ts=8 sw=2 sts=2: */
+
diff --git a/flow/gsl/gslglibhash.cc b/flow/gsl/gslglibhash.cc
new file mode 100644
index 0000000..a8c82b0
--- /dev/null
+++ b/flow/gsl/gslglibhash.cc
@@ -0,0 +1,151 @@
+/* GSL Glib Hashtable implementation
+ * Copyright (C) 2001 Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslglib.h"
+#include <list>
+#include <map>
+
+using std::list;
+using std::pair;
+using std::map;
+
+/*
+ * this uses a map of list to emulate somewhat hashtable like behaviour - note
+ * that insert and remove are O(log N) due to the use of a map, instead of
+ * ~ O(1) which they would be for a "real" hashtable
+ */
+struct _GHashTable
+{
+  GHashFunc hashFunc;
+  GEqualFunc equalFunc;
+  map<guint /*hashvalue for key*/, list< pair<gpointer,gpointer> > /*(key,value) pairs*/> nodes;
+
+  /*Con*/ _GHashTable (GHashFunc hf, GEqualFunc ef) :
+    hashFunc(hf), equalFunc(ef) { }
+};
+
+
+GHashTable* g_hash_table_new               (GHashFunc       hash_func,
+					    GEqualFunc      key_equal_func)
+{
+  return new GHashTable (hash_func?hash_func:g_direct_hash, key_equal_func?key_equal_func:g_direct_equal);
+}
+void        g_hash_table_destroy           (GHashTable     *hash_table)
+{
+  g_return_if_fail (hash_table != NULL);
+
+  delete hash_table;
+}
+void        g_hash_table_insert            (GHashTable     *hash_table,
+					    gpointer        key,
+					    gpointer        value)
+{
+  g_return_if_fail (hash_table != NULL);
+  guint hashvalue = hash_table->hashFunc (key);
+
+  list< pair<gpointer,gpointer> >& bucket = hash_table->nodes[hashvalue];
+  list< pair<gpointer,gpointer> >::iterator i;
+  
+  for (i = bucket.begin(); i != bucket.end(); i++)
+    {
+      if (hash_table->equalFunc(i->first, key))
+      	{
+	  if (value || TRUE)
+	    {
+	      i->second = value; /* overwrite old hash value */
+	      return;
+	    }
+	  else
+	    {
+	      bucket.erase(i); /* remove value */
+
+	      if (bucket.empty()) /* remove bucket if this was the only value */
+	        hash_table->nodes.erase (hashvalue);
+	      return;
+	    }
+	}
+    }
+
+  if (value)
+    hash_table->nodes[hashvalue].push_back(std::make_pair (key, value));
+}
+
+gpointer    g_hash_table_lookup            (GHashTable     *hash_table,
+					    gconstpointer   key)
+{
+  g_return_val_if_fail (hash_table != NULL, NULL);
+
+  guint hashvalue = hash_table->hashFunc (key);
+
+  list< pair<gpointer,gpointer> >& bucket = hash_table->nodes[hashvalue];
+  list< pair<gpointer,gpointer> >::iterator i;
+  
+  for (i = bucket.begin(); i != bucket.end(); i++)
+    {
+      if (hash_table->equalFunc(i->first, key))
+      	return i->second;
+    }
+
+  return 0;
+}
+gboolean    g_hash_table_remove            (GHashTable     *hash_table,
+					    gconstpointer   key)
+{
+  g_return_val_if_fail (hash_table != NULL, FALSE);
+
+  guint hashvalue = hash_table->hashFunc (key);
+
+  list< pair<gpointer,gpointer> >& bucket = hash_table->nodes[hashvalue];
+  list< pair<gpointer,gpointer> >::iterator i;
+  
+  for (i = bucket.begin(); i != bucket.end(); i++)
+    {
+      if (hash_table->equalFunc(i->first, key))
+      	{
+      	  bucket.erase (i);
+
+	  if (bucket.empty()) /* remove bucket if this was the only value */
+	    hash_table->nodes.erase (hashvalue);
+	  return true;
+	}
+    }
+
+  return false;
+}
+
+void        g_hash_table_foreach           (GHashTable     *hash_table,
+					    GHFunc          func,
+					    gpointer        user_data)
+{
+  map<guint, list< pair<gpointer,gpointer> > >::iterator bi;
+
+  g_return_if_fail (hash_table != NULL);
+
+  /* for all buckets */
+  for (bi = hash_table->nodes.begin (); bi != hash_table->nodes.end (); bi++)
+    {
+      list< pair<gpointer,gpointer> >& bucket = bi->second;
+      list< pair<gpointer,gpointer> >::iterator i;
+ 
+      /* for each element in the current bucket */
+      for (i = bucket.begin(); i != bucket.end(); i++)
+        func ((void*) i->first, (void*) i->second, user_data);
+   }
+}
+
+/* vim:set ts=8 sw=2 sts=2: */
diff --git a/flow/gsl/gslglibhashtest.cc b/flow/gsl/gslglibhashtest.cc
new file mode 100644
index 0000000..da50c10
--- /dev/null
+++ b/flow/gsl/gslglibhashtest.cc
@@ -0,0 +1,123 @@
+/* GSL Glib Hashtable test
+ * Copyright (C) 2001 Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsldefs.h"
+#include <string.h>
+
+/* cause hashvalue collisions for the test */
+guint g_str_narrow_hash (gconstpointer key) {
+	return g_str_hash (key) & 15;
+}
+
+struct Test {
+	char *key;
+	char *value;
+	int count;
+} test[50];
+
+void print_func (gpointer key, gpointer value, gpointer user_data) {
+#if 0	 /* <- enable to get printing  of some entries */
+	g_print ("%s: %s = %s\n", user_data, key, value);
+#endif
+}
+
+void fail_func (gpointer key, gpointer value, gpointer user_data) {
+	g_error ("*this* should not have happened");
+}
+
+
+void count_func (gpointer key, gpointer value, gpointer user_data) {
+  g_assert (value != NULL && key != NULL);
+	for(int i=0;i<50;i++)
+	{
+		if(strcmp((char *)key, test[i].key) == 0)
+		{
+			g_assert(strcmp((char *)value, test[i].value) == 0);
+			test[i].count++;
+		}
+	}
+}
+
+
+int main()
+{
+	GHashTable *t = g_hash_table_new (g_str_narrow_hash, g_str_equal);
+
+	for(int i=0;i<50;i++)
+	{
+		test[i].key = g_strdup_printf ("key-%d",i);
+		test[i].value = g_strdup_printf ("value-%d",i);
+		test[i].count = 0;
+
+		g_hash_table_insert (t, test[i].key, test[i].value);
+	}
+
+	g_assert (strcmp ((char *)g_hash_table_lookup (t, "key-24"), "value-24") == 0);
+	g_hash_table_foreach(t, print_func, g_strdup("all-keys-50"));
+	g_hash_table_foreach(t, count_func, 0);
+
+	for(int i=0;i<50;i++)
+	{
+		/* each key should have been found once in the hash table now */
+		g_assert(test[i].count == 1);
+	}
+
+	for(int i=0;i<25;i++)
+	{
+		test[i].key = g_strdup_printf ("key-%d",i);
+		test[i].value = g_strdup_printf ("another-value-%d",i);
+
+		g_hash_table_insert (t, test[i].key, test[i].value);
+	}
+
+	g_assert (strcmp ((char *)g_hash_table_lookup (t, "key-24"), "another-value-24") == 0);
+	g_hash_table_foreach(t, print_func, g_strdup("all-keys-new-25-old-25"));
+	g_hash_table_foreach(t, count_func, 0);
+
+	for(int i=0;i<50;i++)
+	{
+		/* each key should have been found once (with the new value) */
+		g_assert(test[i].count == 2);
+	}
+
+	for(int i=0;i<50;i+=2)
+	{
+		/* remove even valued keys */
+		g_hash_table_remove (t, test[i].key);
+	}
+
+	g_assert (g_hash_table_lookup (t, "key-24") == 0);
+	g_hash_table_foreach(t, print_func, g_strdup("only-odd-keys-25"));
+	g_hash_table_foreach(t, count_func, 0);
+
+	for(int i=0;i<50;i++)
+	{
+		/* only odd keys should be there */
+		g_assert((test[i].count == 3 && (i & 1))
+		      || (test[i].count == 2 && !(i & 1)));
+	}
+
+	for(int i=1;i<50;i+=2)
+	{
+		/* remove odd valued keys */
+		g_hash_table_remove (t, g_strdup(test[i].key));
+	}
+
+	g_hash_table_foreach(t, fail_func, 0);
+	return 0;
+}
diff --git a/flow/gsl/gslieee754.h b/flow/gsl/gslieee754.h
new file mode 100644
index 0000000..48ea0ee
--- /dev/null
+++ b/flow/gsl/gslieee754.h
@@ -0,0 +1,246 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 1999, 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_IEEE754_H__
+#define __GSL_IEEE754_H__
+
+#include	<gsl/gsldefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* IEEE 754 single precision floating point layout:
+ *        31 30           23 22            0
+ * +--------+---------------+---------------+
+ * | s 1bit | e[30:23] 8bit | f[22:0] 23bit |
+ * +--------+---------------+---------------+
+ * B0------------------->B1------->B2-->B3-->
+ *
+ * IEEE 754 double precision floating point layout:
+ *        63 62            52 51            32   31            0
+ * +--------+----------------+----------------+ +---------------+
+ * | s 1bit | e[62:52] 11bit | f[51:32] 20bit | | f[31:0] 32bit |
+ * +--------+----------------+----------------+ +---------------+
+ * B0--------------->B1---------->B2--->B3---->  B4->B5->B6->B7->
+ */
+
+/* floating point type related constants */
+#define GSL_FLOAT_BIAS		 (127)
+#define	GSL_FLOAT_MAX_NORMAL	 (3.40282347e+38)	   /* 7f7fffff */
+#define	GSL_FLOAT_MIN_NORMAL	 (1.17549435e-38)	   /* 00800000 */
+#define	GSL_FLOAT_MAX_SUBNORMAL	 (1.17549421e-38)	   /* 007fffff */
+#define	GSL_FLOAT_MIN_SUBNORMAL	 (1.40129846e-45)	   /* 00000001 */
+#define GSL_DOUBLE_BIAS		 (1023)
+#define	GSL_DOUBLE_MAX_NORMAL	 (1.7976931348623157e+308) /* 7fefffff ffffffff */
+#define	GSL_DOUBLE_MIN_NORMAL	 (2.2250738585072014e-308) /* 00100000 00000000 */
+#define	GSL_DOUBLE_MAX_SUBNORMAL (2.2250738585072009e-308) /* 000fffff ffffffff */
+#define	GSL_DOUBLE_MIN_SUBNORMAL (4.9406564584124654e-324) /* 00000000 00000001 */
+#define	GSL_DOUBLE_INF		 (_gsl_dinf_union.d)
+#define	GSL_DOUBLE_NAN		 (_gsl_dnan_union.d)
+#define	GSL_FLOAT_INF		 (_gsl_finf_union.f)
+#define	GSL_FLOAT_NAN		 (_gsl_fnan_union.f)
+
+/* multiply with base2 exponent to get base10 exponent (for nomal numbers) */
+#define GSL_LOG_2_BASE_10         (0.30102999566398119521)
+
+/* the following macros work only on variables
+ * and evaluate arguments multiple times
+ */
+
+/* single precision value checks */
+#define	GSL_FLOAT_IS_ZERO(f)		((f) == 0.0)	/* compiler knows this one */
+#define	GSL_FLOAT_IS_NORMAL(f)		(GSL_FLOAT_PARTS (f).mpn.biased_exponent > 0 && \
+				         GSL_FLOAT_PARTS (f).mpn.biased_exponent < 255)
+#define	GSL_FLOAT_IS_SUBNORMAL(f)	(GSL_FLOAT_PARTS (f).mpn.biased_exponent == 0 && \
+					 GSL_FLOAT_PARTS (f).mpn.mantissa != 0)
+#define	GSL_FLOAT_IS_NANINF(f)		(GSL_FLOAT_PARTS (f).mpn.biased_exponent == 255)
+#define	GSL_FLOAT_IS_NAN(f)		(GSL_FLOAT_IS_NANINF (f) && GSL_FLOAT_PARTS (f).mpn.mantissa != 0)
+#define	GSL_FLOAT_IS_INF(f)		(GSL_FLOAT_IS_NANINF (f) && GSL_FLOAT_PARTS (f).mpn.mantissa == 0)
+#define	GSL_FLOAT_IS_INF_POSITIVE(f)	(GSL_FLOAT_IS_INF (f) && GSL_FLOAT_PARTS (f).mpn.sign == 0)
+#define	GSL_FLOAT_IS_INF_NEGATIVE(f)	(GSL_FLOAT_IS_INF (f) && GSL_FLOAT_PARTS (f).mpn.sign == 1)
+#define	GSL_FLOAT_SIGN(f)		(GSL_FLOAT_PARTS (f).mpn.sign)
+
+/* double precision value checks */
+#define	GSL_DOUBLE_IS_ZERO(d)		((d) == 0.0)	/* compiler knows this one */
+#define	GSL_DOUBLE_IS_NORMAL(d)		(GSL_DOUBLE_PARTS (d).mpn.biased_exponent > 0 && \
+					 GSL_DOUBLE_PARTS (d).mpn.biased_exponent < 2047)
+#define	GSL_DOUBLE_IS_SUBNORMAL(d)	(GSL_DOUBLE_PARTS (d).mpn.biased_exponent == 0 && \
+                                         (GSL_DOUBLE_PARTS (d).mpn.mantissa_low != 0 || \
+					  GSL_DOUBLE_PARTS (d).mpn.mantissa_high != 0))
+#define	GSL_DOUBLE_IS_NANINF(d)		(GSL_DOUBLE_PARTS (d).mpn.biased_exponent == 2047)
+#define	GSL_DOUBLE_IS_NAN(d)		(GSL_DOUBLE_IS_NANINF (d) && \
+					 (GSL_DOUBLE_PARTS (d).mpn.mantissa_low != 0 || \
+					  GSL_DOUBLE_PARTS (d).mpn.mantissa_high != 0))
+#define	GSL_DOUBLE_IS_INF(d)		(GSL_DOUBLE_IS_NANINF (d) && \
+					 GSL_DOUBLE_PARTS (d).mpn.mantissa_low == 0 && \
+					 GSL_DOUBLE_PARTS (d).mpn.mantissa_high == 0)
+#define	GSL_DOUBLE_IS_INF_POSITIVE(d)	(GSL_DOUBLE_IS_INF (d) && GSL_DOUBLE_PARTS (d).mpn.sign == 0)
+#define	GSL_DOUBLE_IS_INF_NEGATIVE(d)	(GSL_DOUBLE_IS_INF (d) && GSL_DOUBLE_PARTS (d).mpn.sign == 1)
+#define	GSL_DOUBLE_SIGN(d)		(GSL_DOUBLE_PARTS (d).mpn.sign)
+
+/* get structured parts of floating point numbers */
+#define	GSL_FLOAT_PARTS(f)		(*((GslFloatIEEE754*) &(f)))
+#define	GSL_DOUBLE_PARTS(d)		(*((GslDoubleIEEE754*) &(d)))
+
+/* --- rounding --- */
+typedef	unsigned short int	GslFpuState;
+#if defined (__i386__) && defined (__GNUC__)
+/* setting/restoring rounding mode shouldn't actually
+ * be necessary as round-to-nearest is the hardware
+ * default (can be checked with gsl_fpu_okround()).
+ */
+static inline void	gsl_fpu_setround	(GslFpuState		*cw);
+static inline int	gsl_fpu_okround		(void);
+static inline void	gsl_fpu_restore		(GslFpuState		 cv);
+static inline int	gsl_ftoi /* nearest */	(register float		 f)  G_GNUC_CONST;
+static inline int	gsl_dtoi /* nearest */	(register double	 f)  G_GNUC_CONST;
+/* fallbacks for the !386 case are below */
+#endif
+
+
+/* --- implementation bits --- */
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+typedef union
+{
+  float		v_float;
+  struct {
+    unsigned int mantissa : 23;
+    unsigned int biased_exponent : 8;
+    unsigned int sign : 1;
+  } mpn;
+} GslFloatIEEE754;
+typedef union
+{
+  double	v_double;
+  struct {
+    unsigned int mantissa_low : 32;
+    unsigned int mantissa_high : 20;
+    unsigned int biased_exponent : 11;
+    unsigned int sign : 1;
+  } mpn;
+} GslDoubleIEEE754;
+#define	_GSL_DOUBLE_INF_BYTES	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x7f }
+#define	_GSL_DOUBLE_NAN_BYTES	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x7f }
+#define	_GSL_FLOAT_INF_BYTES	{ 0x00, 0x00, 0x80, 0x7f }
+#define	_GSL_FLOAT_NAN_BYTES	{ 0x00, 0x00, 0xc0, 0x7f }
+#elif G_BYTE_ORDER == G_BIG_ENDIAN
+typedef union
+{
+  float         v_float;
+  struct {
+    unsigned int sign : 1;
+    unsigned int biased_exponent : 8;
+    unsigned int mantissa : 23;
+  } mpn;
+} GslFloatIEEE754;
+typedef union
+{
+  double        v_double;
+  struct {
+    unsigned int sign : 1;
+    unsigned int biased_exponent : 11;
+    unsigned int mantissa_high : 20;
+    unsigned int mantissa_low : 32;
+  } mpn;
+} GslDoubleIEEE754;
+#define	_GSL_DOUBLE_INF_BYTES	{ 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
+#define	_GSL_DOUBLE_NAN_BYTES	{ 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
+#define	_GSL_FLOAT_INF_BYTES	{ 0x7f, 0x80, 0x00, 0x00 }
+#define	_GSL_FLOAT_NAN_BYTES	{ 0x7f, 0xc0, 0x00, 0x00 }
+#else /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */
+#error unknown ENDIAN type
+#endif /* !G_LITTLE_ENDIAN && !G_BIG_ENDIAN */
+
+static const union { unsigned char c[8]; double d; } _gsl_dnan_union = { _GSL_DOUBLE_NAN_BYTES };
+static const union { unsigned char c[8]; double d; } _gsl_dinf_union = { _GSL_DOUBLE_INF_BYTES };
+static const union { unsigned char c[4]; float f; }  _gsl_fnan_union = { _GSL_FLOAT_NAN_BYTES };
+static const union { unsigned char c[4]; float f; }  _gsl_finf_union = { _GSL_FLOAT_INF_BYTES };
+
+#if defined (__i386__) && defined (__GNUC__)
+static inline void
+gsl_fpu_setround (GslFpuState *cw)
+{
+  GslFpuState cv;
+  
+  __asm__ ("fnstcw %0"
+	   : "=m" (*&cv));
+  *cw = cv;
+  cv &= ~0x0c00;
+  __asm__ ("fldcw %0"
+	   :
+	   : "m" (*&cv));
+}
+static inline int
+gsl_fpu_okround (void)
+{
+  GslFpuState cv;
+  
+  __asm__ ("fnstcw %0"
+	   : "=m" (*&cv));
+  return !(cv & 0x0c00);
+}
+static inline void
+gsl_fpu_restore (GslFpuState cv)
+{
+  __asm__ ("fldcw %0"
+	   :
+	   : "m" (*&cv));
+}
+static inline int G_GNUC_CONST
+gsl_ftoi (register float f)
+{
+  int r;
+  
+  __asm__ ("fistl %0"
+	   : "=m" (r)
+	   : "t" (f));
+  return r;
+}
+static inline int G_GNUC_CONST
+gsl_dtoi (register double f)
+{
+  int r;
+  
+  __asm__ ("fistl %0"
+	   : "=m" (r)
+	   : "t" (f));
+  return r;
+}
+#else   /* !386 */
+#  define gsl_fpu_setround(p)   ((void) (p));
+#  define gsl_fpu_okround()     (1)
+#  define gsl_fpu_restore(x)    /* nop */
+static inline int G_GNUC_CONST
+gsl_ftoi (register float v)
+{
+  return v < -0.0 ? v - 0.5 : v + 0.5;
+}
+static inline int G_GNUC_CONST
+gsl_dtoi (register double v)
+{
+  return v < -0.0 ? v - 0.5 : v + 0.5;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_IEEE754_H__ */		/* vim: set ts=8 sw=2 sts=2: */
diff --git a/flow/gsl/gslincluder.c b/flow/gsl/gslincluder.c
new file mode 100644
index 0000000..4ed4e85
--- /dev/null
+++ b/flow/gsl/gslincluder.c
@@ -0,0 +1,13420 @@
+/* GSL - Generic Sound Layer
+ *
+ * This file 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 Library General Public License for more details.
+ */
+
+#if 0
+/* script, used to create this file's contents:
+ */
+{
+  my $first_case = 0;
+  my $last_case = 1024;
+  my $i;
+  
+  print "#define GSL_INCLUDER_MAKE_FUNC(name,case) GSL_INCLUDER_CONCAT3 (name, __, case)\n";
+  print "#define GSL_INCLUDER_CONCAT3(x,y,z)       x ## y ## z\n";
+  print "#define GSL_INCLUDER_FUNC                 GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, GSL_INCLUDER_CASE)\n";
+  print "#ifndef GSL_INCLUDER_REJECT\n";
+  print "#define GSL_INCLUDER_REJECT(icase)        0\n";
+  print "#endif\n";
+  print "\n";
+  print "/* check range: $first_case .. $last_case */\n";
+  print "#if     (GSL_INCLUDER_FIRST_CASE < $first_case)\n";
+  print "#error GSL_INCLUDER_FIRST_CASE < $first_case is not supported\n";
+  print "#endif\n";
+  print "#if     (GSL_INCLUDER_LAST_CASE > $last_case)\n";
+  print "#error GSL_INCLUDER_LAST_CASE > $last_case is not supported\n";
+  print "#endif\n";
+  print "\n";
+  for ($i = $first_case; $i <= $last_case; $i++)
+    {
+      print "/* $i */\n";
+      print "#if     (($i >= GSL_INCLUDER_FIRST_CASE) && ($i <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT ($i)))\n";
+      print "#define  GSL_INCLUDER_CASE       $i\n";
+      print "#include GSL_INCLUDER_FILE\n";
+      print "#undef   GSL_INCLUDER_CASE\n";
+      print "#endif\n";
+    }
+  print "\n";
+  print "GSL_INCLUDER_TABLE = {\n";
+  for ($i = $first_case; $i <= $last_case; $i++)
+    {
+      print "#if     (($i >= GSL_INCLUDER_FIRST_CASE) && ($i <= GSL_INCLUDER_LAST_CASE))\n";
+      print "#if     (GSL_INCLUDER_REJECT ($i))\n";
+      print "  NULL,\n";
+      print "#else\n";
+      print "  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, $i),\n";
+      print "#endif\n";
+      print "#endif\n";
+    }
+  print "};\n";
+  print "\n";
+  print "#undef GSL_INCLUDER_REJECT\n";
+  print "#undef GSL_INCLUDER_FUNC\n";
+  print "#undef GSL_INCLUDER_CONCAT3\n";
+  print "#undef GSL_INCLUDER_MAKE_FUNC\n";
+  print "#undef GSL_INCLUDER_FIRST_CASE\n";
+  print "#undef GSL_INCLUDER_LAST_CASE\n";
+  print "#undef GSL_INCLUDER_NAME\n";
+  print "#undef GSL_INCLUDER_TABLE\n";
+  print "#undef GSL_INCLUDER_FILE\n";
+}
+#endif
+
+
+#define GSL_INCLUDER_MAKE_FUNC(name,case) GSL_INCLUDER_CONCAT3 (name, __, case)
+#define GSL_INCLUDER_CONCAT3(x,y,z)       x ## y ## z
+#define GSL_INCLUDER_FUNC                 GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, GSL_INCLUDER_CASE)
+#ifndef GSL_INCLUDER_REJECT
+#define GSL_INCLUDER_REJECT(icase)        0
+#endif
+
+/* check range: 0 .. 1024 */
+#if     (GSL_INCLUDER_FIRST_CASE < 0)
+#error GSL_INCLUDER_FIRST_CASE < 0 is not supported
+#endif
+#if     (GSL_INCLUDER_LAST_CASE > 1024)
+#error GSL_INCLUDER_LAST_CASE > 1024 is not supported
+#endif
+
+/* 0 */
+#if     ((0 >= GSL_INCLUDER_FIRST_CASE) && (0 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (0)))
+#define  GSL_INCLUDER_CASE       0
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1 */
+#if     ((1 >= GSL_INCLUDER_FIRST_CASE) && (1 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1)))
+#define  GSL_INCLUDER_CASE       1
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 2 */
+#if     ((2 >= GSL_INCLUDER_FIRST_CASE) && (2 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (2)))
+#define  GSL_INCLUDER_CASE       2
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 3 */
+#if     ((3 >= GSL_INCLUDER_FIRST_CASE) && (3 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (3)))
+#define  GSL_INCLUDER_CASE       3
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 4 */
+#if     ((4 >= GSL_INCLUDER_FIRST_CASE) && (4 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (4)))
+#define  GSL_INCLUDER_CASE       4
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 5 */
+#if     ((5 >= GSL_INCLUDER_FIRST_CASE) && (5 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (5)))
+#define  GSL_INCLUDER_CASE       5
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 6 */
+#if     ((6 >= GSL_INCLUDER_FIRST_CASE) && (6 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (6)))
+#define  GSL_INCLUDER_CASE       6
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 7 */
+#if     ((7 >= GSL_INCLUDER_FIRST_CASE) && (7 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (7)))
+#define  GSL_INCLUDER_CASE       7
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 8 */
+#if     ((8 >= GSL_INCLUDER_FIRST_CASE) && (8 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (8)))
+#define  GSL_INCLUDER_CASE       8
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 9 */
+#if     ((9 >= GSL_INCLUDER_FIRST_CASE) && (9 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (9)))
+#define  GSL_INCLUDER_CASE       9
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 10 */
+#if     ((10 >= GSL_INCLUDER_FIRST_CASE) && (10 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (10)))
+#define  GSL_INCLUDER_CASE       10
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 11 */
+#if     ((11 >= GSL_INCLUDER_FIRST_CASE) && (11 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (11)))
+#define  GSL_INCLUDER_CASE       11
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 12 */
+#if     ((12 >= GSL_INCLUDER_FIRST_CASE) && (12 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (12)))
+#define  GSL_INCLUDER_CASE       12
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 13 */
+#if     ((13 >= GSL_INCLUDER_FIRST_CASE) && (13 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (13)))
+#define  GSL_INCLUDER_CASE       13
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 14 */
+#if     ((14 >= GSL_INCLUDER_FIRST_CASE) && (14 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (14)))
+#define  GSL_INCLUDER_CASE       14
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 15 */
+#if     ((15 >= GSL_INCLUDER_FIRST_CASE) && (15 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (15)))
+#define  GSL_INCLUDER_CASE       15
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 16 */
+#if     ((16 >= GSL_INCLUDER_FIRST_CASE) && (16 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (16)))
+#define  GSL_INCLUDER_CASE       16
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 17 */
+#if     ((17 >= GSL_INCLUDER_FIRST_CASE) && (17 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (17)))
+#define  GSL_INCLUDER_CASE       17
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 18 */
+#if     ((18 >= GSL_INCLUDER_FIRST_CASE) && (18 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (18)))
+#define  GSL_INCLUDER_CASE       18
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 19 */
+#if     ((19 >= GSL_INCLUDER_FIRST_CASE) && (19 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (19)))
+#define  GSL_INCLUDER_CASE       19
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 20 */
+#if     ((20 >= GSL_INCLUDER_FIRST_CASE) && (20 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (20)))
+#define  GSL_INCLUDER_CASE       20
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 21 */
+#if     ((21 >= GSL_INCLUDER_FIRST_CASE) && (21 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (21)))
+#define  GSL_INCLUDER_CASE       21
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 22 */
+#if     ((22 >= GSL_INCLUDER_FIRST_CASE) && (22 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (22)))
+#define  GSL_INCLUDER_CASE       22
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 23 */
+#if     ((23 >= GSL_INCLUDER_FIRST_CASE) && (23 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (23)))
+#define  GSL_INCLUDER_CASE       23
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 24 */
+#if     ((24 >= GSL_INCLUDER_FIRST_CASE) && (24 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (24)))
+#define  GSL_INCLUDER_CASE       24
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 25 */
+#if     ((25 >= GSL_INCLUDER_FIRST_CASE) && (25 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (25)))
+#define  GSL_INCLUDER_CASE       25
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 26 */
+#if     ((26 >= GSL_INCLUDER_FIRST_CASE) && (26 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (26)))
+#define  GSL_INCLUDER_CASE       26
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 27 */
+#if     ((27 >= GSL_INCLUDER_FIRST_CASE) && (27 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (27)))
+#define  GSL_INCLUDER_CASE       27
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 28 */
+#if     ((28 >= GSL_INCLUDER_FIRST_CASE) && (28 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (28)))
+#define  GSL_INCLUDER_CASE       28
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 29 */
+#if     ((29 >= GSL_INCLUDER_FIRST_CASE) && (29 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (29)))
+#define  GSL_INCLUDER_CASE       29
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 30 */
+#if     ((30 >= GSL_INCLUDER_FIRST_CASE) && (30 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (30)))
+#define  GSL_INCLUDER_CASE       30
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 31 */
+#if     ((31 >= GSL_INCLUDER_FIRST_CASE) && (31 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (31)))
+#define  GSL_INCLUDER_CASE       31
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 32 */
+#if     ((32 >= GSL_INCLUDER_FIRST_CASE) && (32 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (32)))
+#define  GSL_INCLUDER_CASE       32
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 33 */
+#if     ((33 >= GSL_INCLUDER_FIRST_CASE) && (33 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (33)))
+#define  GSL_INCLUDER_CASE       33
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 34 */
+#if     ((34 >= GSL_INCLUDER_FIRST_CASE) && (34 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (34)))
+#define  GSL_INCLUDER_CASE       34
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 35 */
+#if     ((35 >= GSL_INCLUDER_FIRST_CASE) && (35 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (35)))
+#define  GSL_INCLUDER_CASE       35
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 36 */
+#if     ((36 >= GSL_INCLUDER_FIRST_CASE) && (36 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (36)))
+#define  GSL_INCLUDER_CASE       36
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 37 */
+#if     ((37 >= GSL_INCLUDER_FIRST_CASE) && (37 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (37)))
+#define  GSL_INCLUDER_CASE       37
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 38 */
+#if     ((38 >= GSL_INCLUDER_FIRST_CASE) && (38 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (38)))
+#define  GSL_INCLUDER_CASE       38
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 39 */
+#if     ((39 >= GSL_INCLUDER_FIRST_CASE) && (39 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (39)))
+#define  GSL_INCLUDER_CASE       39
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 40 */
+#if     ((40 >= GSL_INCLUDER_FIRST_CASE) && (40 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (40)))
+#define  GSL_INCLUDER_CASE       40
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 41 */
+#if     ((41 >= GSL_INCLUDER_FIRST_CASE) && (41 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (41)))
+#define  GSL_INCLUDER_CASE       41
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 42 */
+#if     ((42 >= GSL_INCLUDER_FIRST_CASE) && (42 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (42)))
+#define  GSL_INCLUDER_CASE       42
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 43 */
+#if     ((43 >= GSL_INCLUDER_FIRST_CASE) && (43 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (43)))
+#define  GSL_INCLUDER_CASE       43
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 44 */
+#if     ((44 >= GSL_INCLUDER_FIRST_CASE) && (44 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (44)))
+#define  GSL_INCLUDER_CASE       44
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 45 */
+#if     ((45 >= GSL_INCLUDER_FIRST_CASE) && (45 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (45)))
+#define  GSL_INCLUDER_CASE       45
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 46 */
+#if     ((46 >= GSL_INCLUDER_FIRST_CASE) && (46 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (46)))
+#define  GSL_INCLUDER_CASE       46
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 47 */
+#if     ((47 >= GSL_INCLUDER_FIRST_CASE) && (47 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (47)))
+#define  GSL_INCLUDER_CASE       47
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 48 */
+#if     ((48 >= GSL_INCLUDER_FIRST_CASE) && (48 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (48)))
+#define  GSL_INCLUDER_CASE       48
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 49 */
+#if     ((49 >= GSL_INCLUDER_FIRST_CASE) && (49 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (49)))
+#define  GSL_INCLUDER_CASE       49
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 50 */
+#if     ((50 >= GSL_INCLUDER_FIRST_CASE) && (50 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (50)))
+#define  GSL_INCLUDER_CASE       50
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 51 */
+#if     ((51 >= GSL_INCLUDER_FIRST_CASE) && (51 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (51)))
+#define  GSL_INCLUDER_CASE       51
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 52 */
+#if     ((52 >= GSL_INCLUDER_FIRST_CASE) && (52 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (52)))
+#define  GSL_INCLUDER_CASE       52
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 53 */
+#if     ((53 >= GSL_INCLUDER_FIRST_CASE) && (53 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (53)))
+#define  GSL_INCLUDER_CASE       53
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 54 */
+#if     ((54 >= GSL_INCLUDER_FIRST_CASE) && (54 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (54)))
+#define  GSL_INCLUDER_CASE       54
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 55 */
+#if     ((55 >= GSL_INCLUDER_FIRST_CASE) && (55 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (55)))
+#define  GSL_INCLUDER_CASE       55
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 56 */
+#if     ((56 >= GSL_INCLUDER_FIRST_CASE) && (56 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (56)))
+#define  GSL_INCLUDER_CASE       56
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 57 */
+#if     ((57 >= GSL_INCLUDER_FIRST_CASE) && (57 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (57)))
+#define  GSL_INCLUDER_CASE       57
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 58 */
+#if     ((58 >= GSL_INCLUDER_FIRST_CASE) && (58 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (58)))
+#define  GSL_INCLUDER_CASE       58
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 59 */
+#if     ((59 >= GSL_INCLUDER_FIRST_CASE) && (59 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (59)))
+#define  GSL_INCLUDER_CASE       59
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 60 */
+#if     ((60 >= GSL_INCLUDER_FIRST_CASE) && (60 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (60)))
+#define  GSL_INCLUDER_CASE       60
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 61 */
+#if     ((61 >= GSL_INCLUDER_FIRST_CASE) && (61 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (61)))
+#define  GSL_INCLUDER_CASE       61
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 62 */
+#if     ((62 >= GSL_INCLUDER_FIRST_CASE) && (62 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (62)))
+#define  GSL_INCLUDER_CASE       62
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 63 */
+#if     ((63 >= GSL_INCLUDER_FIRST_CASE) && (63 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (63)))
+#define  GSL_INCLUDER_CASE       63
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 64 */
+#if     ((64 >= GSL_INCLUDER_FIRST_CASE) && (64 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (64)))
+#define  GSL_INCLUDER_CASE       64
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 65 */
+#if     ((65 >= GSL_INCLUDER_FIRST_CASE) && (65 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (65)))
+#define  GSL_INCLUDER_CASE       65
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 66 */
+#if     ((66 >= GSL_INCLUDER_FIRST_CASE) && (66 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (66)))
+#define  GSL_INCLUDER_CASE       66
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 67 */
+#if     ((67 >= GSL_INCLUDER_FIRST_CASE) && (67 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (67)))
+#define  GSL_INCLUDER_CASE       67
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 68 */
+#if     ((68 >= GSL_INCLUDER_FIRST_CASE) && (68 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (68)))
+#define  GSL_INCLUDER_CASE       68
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 69 */
+#if     ((69 >= GSL_INCLUDER_FIRST_CASE) && (69 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (69)))
+#define  GSL_INCLUDER_CASE       69
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 70 */
+#if     ((70 >= GSL_INCLUDER_FIRST_CASE) && (70 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (70)))
+#define  GSL_INCLUDER_CASE       70
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 71 */
+#if     ((71 >= GSL_INCLUDER_FIRST_CASE) && (71 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (71)))
+#define  GSL_INCLUDER_CASE       71
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 72 */
+#if     ((72 >= GSL_INCLUDER_FIRST_CASE) && (72 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (72)))
+#define  GSL_INCLUDER_CASE       72
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 73 */
+#if     ((73 >= GSL_INCLUDER_FIRST_CASE) && (73 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (73)))
+#define  GSL_INCLUDER_CASE       73
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 74 */
+#if     ((74 >= GSL_INCLUDER_FIRST_CASE) && (74 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (74)))
+#define  GSL_INCLUDER_CASE       74
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 75 */
+#if     ((75 >= GSL_INCLUDER_FIRST_CASE) && (75 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (75)))
+#define  GSL_INCLUDER_CASE       75
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 76 */
+#if     ((76 >= GSL_INCLUDER_FIRST_CASE) && (76 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (76)))
+#define  GSL_INCLUDER_CASE       76
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 77 */
+#if     ((77 >= GSL_INCLUDER_FIRST_CASE) && (77 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (77)))
+#define  GSL_INCLUDER_CASE       77
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 78 */
+#if     ((78 >= GSL_INCLUDER_FIRST_CASE) && (78 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (78)))
+#define  GSL_INCLUDER_CASE       78
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 79 */
+#if     ((79 >= GSL_INCLUDER_FIRST_CASE) && (79 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (79)))
+#define  GSL_INCLUDER_CASE       79
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 80 */
+#if     ((80 >= GSL_INCLUDER_FIRST_CASE) && (80 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (80)))
+#define  GSL_INCLUDER_CASE       80
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 81 */
+#if     ((81 >= GSL_INCLUDER_FIRST_CASE) && (81 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (81)))
+#define  GSL_INCLUDER_CASE       81
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 82 */
+#if     ((82 >= GSL_INCLUDER_FIRST_CASE) && (82 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (82)))
+#define  GSL_INCLUDER_CASE       82
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 83 */
+#if     ((83 >= GSL_INCLUDER_FIRST_CASE) && (83 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (83)))
+#define  GSL_INCLUDER_CASE       83
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 84 */
+#if     ((84 >= GSL_INCLUDER_FIRST_CASE) && (84 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (84)))
+#define  GSL_INCLUDER_CASE       84
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 85 */
+#if     ((85 >= GSL_INCLUDER_FIRST_CASE) && (85 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (85)))
+#define  GSL_INCLUDER_CASE       85
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 86 */
+#if     ((86 >= GSL_INCLUDER_FIRST_CASE) && (86 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (86)))
+#define  GSL_INCLUDER_CASE       86
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 87 */
+#if     ((87 >= GSL_INCLUDER_FIRST_CASE) && (87 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (87)))
+#define  GSL_INCLUDER_CASE       87
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 88 */
+#if     ((88 >= GSL_INCLUDER_FIRST_CASE) && (88 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (88)))
+#define  GSL_INCLUDER_CASE       88
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 89 */
+#if     ((89 >= GSL_INCLUDER_FIRST_CASE) && (89 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (89)))
+#define  GSL_INCLUDER_CASE       89
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 90 */
+#if     ((90 >= GSL_INCLUDER_FIRST_CASE) && (90 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (90)))
+#define  GSL_INCLUDER_CASE       90
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 91 */
+#if     ((91 >= GSL_INCLUDER_FIRST_CASE) && (91 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (91)))
+#define  GSL_INCLUDER_CASE       91
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 92 */
+#if     ((92 >= GSL_INCLUDER_FIRST_CASE) && (92 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (92)))
+#define  GSL_INCLUDER_CASE       92
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 93 */
+#if     ((93 >= GSL_INCLUDER_FIRST_CASE) && (93 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (93)))
+#define  GSL_INCLUDER_CASE       93
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 94 */
+#if     ((94 >= GSL_INCLUDER_FIRST_CASE) && (94 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (94)))
+#define  GSL_INCLUDER_CASE       94
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 95 */
+#if     ((95 >= GSL_INCLUDER_FIRST_CASE) && (95 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (95)))
+#define  GSL_INCLUDER_CASE       95
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 96 */
+#if     ((96 >= GSL_INCLUDER_FIRST_CASE) && (96 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (96)))
+#define  GSL_INCLUDER_CASE       96
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 97 */
+#if     ((97 >= GSL_INCLUDER_FIRST_CASE) && (97 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (97)))
+#define  GSL_INCLUDER_CASE       97
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 98 */
+#if     ((98 >= GSL_INCLUDER_FIRST_CASE) && (98 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (98)))
+#define  GSL_INCLUDER_CASE       98
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 99 */
+#if     ((99 >= GSL_INCLUDER_FIRST_CASE) && (99 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (99)))
+#define  GSL_INCLUDER_CASE       99
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 100 */
+#if     ((100 >= GSL_INCLUDER_FIRST_CASE) && (100 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (100)))
+#define  GSL_INCLUDER_CASE       100
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 101 */
+#if     ((101 >= GSL_INCLUDER_FIRST_CASE) && (101 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (101)))
+#define  GSL_INCLUDER_CASE       101
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 102 */
+#if     ((102 >= GSL_INCLUDER_FIRST_CASE) && (102 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (102)))
+#define  GSL_INCLUDER_CASE       102
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 103 */
+#if     ((103 >= GSL_INCLUDER_FIRST_CASE) && (103 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (103)))
+#define  GSL_INCLUDER_CASE       103
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 104 */
+#if     ((104 >= GSL_INCLUDER_FIRST_CASE) && (104 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (104)))
+#define  GSL_INCLUDER_CASE       104
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 105 */
+#if     ((105 >= GSL_INCLUDER_FIRST_CASE) && (105 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (105)))
+#define  GSL_INCLUDER_CASE       105
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 106 */
+#if     ((106 >= GSL_INCLUDER_FIRST_CASE) && (106 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (106)))
+#define  GSL_INCLUDER_CASE       106
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 107 */
+#if     ((107 >= GSL_INCLUDER_FIRST_CASE) && (107 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (107)))
+#define  GSL_INCLUDER_CASE       107
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 108 */
+#if     ((108 >= GSL_INCLUDER_FIRST_CASE) && (108 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (108)))
+#define  GSL_INCLUDER_CASE       108
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 109 */
+#if     ((109 >= GSL_INCLUDER_FIRST_CASE) && (109 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (109)))
+#define  GSL_INCLUDER_CASE       109
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 110 */
+#if     ((110 >= GSL_INCLUDER_FIRST_CASE) && (110 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (110)))
+#define  GSL_INCLUDER_CASE       110
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 111 */
+#if     ((111 >= GSL_INCLUDER_FIRST_CASE) && (111 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (111)))
+#define  GSL_INCLUDER_CASE       111
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 112 */
+#if     ((112 >= GSL_INCLUDER_FIRST_CASE) && (112 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (112)))
+#define  GSL_INCLUDER_CASE       112
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 113 */
+#if     ((113 >= GSL_INCLUDER_FIRST_CASE) && (113 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (113)))
+#define  GSL_INCLUDER_CASE       113
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 114 */
+#if     ((114 >= GSL_INCLUDER_FIRST_CASE) && (114 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (114)))
+#define  GSL_INCLUDER_CASE       114
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 115 */
+#if     ((115 >= GSL_INCLUDER_FIRST_CASE) && (115 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (115)))
+#define  GSL_INCLUDER_CASE       115
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 116 */
+#if     ((116 >= GSL_INCLUDER_FIRST_CASE) && (116 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (116)))
+#define  GSL_INCLUDER_CASE       116
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 117 */
+#if     ((117 >= GSL_INCLUDER_FIRST_CASE) && (117 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (117)))
+#define  GSL_INCLUDER_CASE       117
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 118 */
+#if     ((118 >= GSL_INCLUDER_FIRST_CASE) && (118 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (118)))
+#define  GSL_INCLUDER_CASE       118
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 119 */
+#if     ((119 >= GSL_INCLUDER_FIRST_CASE) && (119 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (119)))
+#define  GSL_INCLUDER_CASE       119
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 120 */
+#if     ((120 >= GSL_INCLUDER_FIRST_CASE) && (120 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (120)))
+#define  GSL_INCLUDER_CASE       120
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 121 */
+#if     ((121 >= GSL_INCLUDER_FIRST_CASE) && (121 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (121)))
+#define  GSL_INCLUDER_CASE       121
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 122 */
+#if     ((122 >= GSL_INCLUDER_FIRST_CASE) && (122 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (122)))
+#define  GSL_INCLUDER_CASE       122
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 123 */
+#if     ((123 >= GSL_INCLUDER_FIRST_CASE) && (123 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (123)))
+#define  GSL_INCLUDER_CASE       123
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 124 */
+#if     ((124 >= GSL_INCLUDER_FIRST_CASE) && (124 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (124)))
+#define  GSL_INCLUDER_CASE       124
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 125 */
+#if     ((125 >= GSL_INCLUDER_FIRST_CASE) && (125 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (125)))
+#define  GSL_INCLUDER_CASE       125
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 126 */
+#if     ((126 >= GSL_INCLUDER_FIRST_CASE) && (126 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (126)))
+#define  GSL_INCLUDER_CASE       126
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 127 */
+#if     ((127 >= GSL_INCLUDER_FIRST_CASE) && (127 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (127)))
+#define  GSL_INCLUDER_CASE       127
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 128 */
+#if     ((128 >= GSL_INCLUDER_FIRST_CASE) && (128 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (128)))
+#define  GSL_INCLUDER_CASE       128
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 129 */
+#if     ((129 >= GSL_INCLUDER_FIRST_CASE) && (129 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (129)))
+#define  GSL_INCLUDER_CASE       129
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 130 */
+#if     ((130 >= GSL_INCLUDER_FIRST_CASE) && (130 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (130)))
+#define  GSL_INCLUDER_CASE       130
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 131 */
+#if     ((131 >= GSL_INCLUDER_FIRST_CASE) && (131 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (131)))
+#define  GSL_INCLUDER_CASE       131
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 132 */
+#if     ((132 >= GSL_INCLUDER_FIRST_CASE) && (132 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (132)))
+#define  GSL_INCLUDER_CASE       132
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 133 */
+#if     ((133 >= GSL_INCLUDER_FIRST_CASE) && (133 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (133)))
+#define  GSL_INCLUDER_CASE       133
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 134 */
+#if     ((134 >= GSL_INCLUDER_FIRST_CASE) && (134 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (134)))
+#define  GSL_INCLUDER_CASE       134
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 135 */
+#if     ((135 >= GSL_INCLUDER_FIRST_CASE) && (135 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (135)))
+#define  GSL_INCLUDER_CASE       135
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 136 */
+#if     ((136 >= GSL_INCLUDER_FIRST_CASE) && (136 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (136)))
+#define  GSL_INCLUDER_CASE       136
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 137 */
+#if     ((137 >= GSL_INCLUDER_FIRST_CASE) && (137 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (137)))
+#define  GSL_INCLUDER_CASE       137
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 138 */
+#if     ((138 >= GSL_INCLUDER_FIRST_CASE) && (138 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (138)))
+#define  GSL_INCLUDER_CASE       138
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 139 */
+#if     ((139 >= GSL_INCLUDER_FIRST_CASE) && (139 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (139)))
+#define  GSL_INCLUDER_CASE       139
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 140 */
+#if     ((140 >= GSL_INCLUDER_FIRST_CASE) && (140 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (140)))
+#define  GSL_INCLUDER_CASE       140
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 141 */
+#if     ((141 >= GSL_INCLUDER_FIRST_CASE) && (141 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (141)))
+#define  GSL_INCLUDER_CASE       141
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 142 */
+#if     ((142 >= GSL_INCLUDER_FIRST_CASE) && (142 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (142)))
+#define  GSL_INCLUDER_CASE       142
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 143 */
+#if     ((143 >= GSL_INCLUDER_FIRST_CASE) && (143 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (143)))
+#define  GSL_INCLUDER_CASE       143
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 144 */
+#if     ((144 >= GSL_INCLUDER_FIRST_CASE) && (144 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (144)))
+#define  GSL_INCLUDER_CASE       144
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 145 */
+#if     ((145 >= GSL_INCLUDER_FIRST_CASE) && (145 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (145)))
+#define  GSL_INCLUDER_CASE       145
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 146 */
+#if     ((146 >= GSL_INCLUDER_FIRST_CASE) && (146 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (146)))
+#define  GSL_INCLUDER_CASE       146
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 147 */
+#if     ((147 >= GSL_INCLUDER_FIRST_CASE) && (147 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (147)))
+#define  GSL_INCLUDER_CASE       147
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 148 */
+#if     ((148 >= GSL_INCLUDER_FIRST_CASE) && (148 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (148)))
+#define  GSL_INCLUDER_CASE       148
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 149 */
+#if     ((149 >= GSL_INCLUDER_FIRST_CASE) && (149 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (149)))
+#define  GSL_INCLUDER_CASE       149
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 150 */
+#if     ((150 >= GSL_INCLUDER_FIRST_CASE) && (150 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (150)))
+#define  GSL_INCLUDER_CASE       150
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 151 */
+#if     ((151 >= GSL_INCLUDER_FIRST_CASE) && (151 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (151)))
+#define  GSL_INCLUDER_CASE       151
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 152 */
+#if     ((152 >= GSL_INCLUDER_FIRST_CASE) && (152 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (152)))
+#define  GSL_INCLUDER_CASE       152
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 153 */
+#if     ((153 >= GSL_INCLUDER_FIRST_CASE) && (153 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (153)))
+#define  GSL_INCLUDER_CASE       153
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 154 */
+#if     ((154 >= GSL_INCLUDER_FIRST_CASE) && (154 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (154)))
+#define  GSL_INCLUDER_CASE       154
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 155 */
+#if     ((155 >= GSL_INCLUDER_FIRST_CASE) && (155 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (155)))
+#define  GSL_INCLUDER_CASE       155
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 156 */
+#if     ((156 >= GSL_INCLUDER_FIRST_CASE) && (156 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (156)))
+#define  GSL_INCLUDER_CASE       156
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 157 */
+#if     ((157 >= GSL_INCLUDER_FIRST_CASE) && (157 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (157)))
+#define  GSL_INCLUDER_CASE       157
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 158 */
+#if     ((158 >= GSL_INCLUDER_FIRST_CASE) && (158 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (158)))
+#define  GSL_INCLUDER_CASE       158
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 159 */
+#if     ((159 >= GSL_INCLUDER_FIRST_CASE) && (159 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (159)))
+#define  GSL_INCLUDER_CASE       159
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 160 */
+#if     ((160 >= GSL_INCLUDER_FIRST_CASE) && (160 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (160)))
+#define  GSL_INCLUDER_CASE       160
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 161 */
+#if     ((161 >= GSL_INCLUDER_FIRST_CASE) && (161 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (161)))
+#define  GSL_INCLUDER_CASE       161
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 162 */
+#if     ((162 >= GSL_INCLUDER_FIRST_CASE) && (162 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (162)))
+#define  GSL_INCLUDER_CASE       162
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 163 */
+#if     ((163 >= GSL_INCLUDER_FIRST_CASE) && (163 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (163)))
+#define  GSL_INCLUDER_CASE       163
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 164 */
+#if     ((164 >= GSL_INCLUDER_FIRST_CASE) && (164 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (164)))
+#define  GSL_INCLUDER_CASE       164
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 165 */
+#if     ((165 >= GSL_INCLUDER_FIRST_CASE) && (165 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (165)))
+#define  GSL_INCLUDER_CASE       165
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 166 */
+#if     ((166 >= GSL_INCLUDER_FIRST_CASE) && (166 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (166)))
+#define  GSL_INCLUDER_CASE       166
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 167 */
+#if     ((167 >= GSL_INCLUDER_FIRST_CASE) && (167 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (167)))
+#define  GSL_INCLUDER_CASE       167
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 168 */
+#if     ((168 >= GSL_INCLUDER_FIRST_CASE) && (168 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (168)))
+#define  GSL_INCLUDER_CASE       168
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 169 */
+#if     ((169 >= GSL_INCLUDER_FIRST_CASE) && (169 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (169)))
+#define  GSL_INCLUDER_CASE       169
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 170 */
+#if     ((170 >= GSL_INCLUDER_FIRST_CASE) && (170 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (170)))
+#define  GSL_INCLUDER_CASE       170
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 171 */
+#if     ((171 >= GSL_INCLUDER_FIRST_CASE) && (171 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (171)))
+#define  GSL_INCLUDER_CASE       171
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 172 */
+#if     ((172 >= GSL_INCLUDER_FIRST_CASE) && (172 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (172)))
+#define  GSL_INCLUDER_CASE       172
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 173 */
+#if     ((173 >= GSL_INCLUDER_FIRST_CASE) && (173 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (173)))
+#define  GSL_INCLUDER_CASE       173
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 174 */
+#if     ((174 >= GSL_INCLUDER_FIRST_CASE) && (174 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (174)))
+#define  GSL_INCLUDER_CASE       174
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 175 */
+#if     ((175 >= GSL_INCLUDER_FIRST_CASE) && (175 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (175)))
+#define  GSL_INCLUDER_CASE       175
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 176 */
+#if     ((176 >= GSL_INCLUDER_FIRST_CASE) && (176 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (176)))
+#define  GSL_INCLUDER_CASE       176
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 177 */
+#if     ((177 >= GSL_INCLUDER_FIRST_CASE) && (177 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (177)))
+#define  GSL_INCLUDER_CASE       177
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 178 */
+#if     ((178 >= GSL_INCLUDER_FIRST_CASE) && (178 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (178)))
+#define  GSL_INCLUDER_CASE       178
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 179 */
+#if     ((179 >= GSL_INCLUDER_FIRST_CASE) && (179 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (179)))
+#define  GSL_INCLUDER_CASE       179
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 180 */
+#if     ((180 >= GSL_INCLUDER_FIRST_CASE) && (180 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (180)))
+#define  GSL_INCLUDER_CASE       180
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 181 */
+#if     ((181 >= GSL_INCLUDER_FIRST_CASE) && (181 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (181)))
+#define  GSL_INCLUDER_CASE       181
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 182 */
+#if     ((182 >= GSL_INCLUDER_FIRST_CASE) && (182 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (182)))
+#define  GSL_INCLUDER_CASE       182
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 183 */
+#if     ((183 >= GSL_INCLUDER_FIRST_CASE) && (183 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (183)))
+#define  GSL_INCLUDER_CASE       183
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 184 */
+#if     ((184 >= GSL_INCLUDER_FIRST_CASE) && (184 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (184)))
+#define  GSL_INCLUDER_CASE       184
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 185 */
+#if     ((185 >= GSL_INCLUDER_FIRST_CASE) && (185 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (185)))
+#define  GSL_INCLUDER_CASE       185
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 186 */
+#if     ((186 >= GSL_INCLUDER_FIRST_CASE) && (186 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (186)))
+#define  GSL_INCLUDER_CASE       186
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 187 */
+#if     ((187 >= GSL_INCLUDER_FIRST_CASE) && (187 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (187)))
+#define  GSL_INCLUDER_CASE       187
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 188 */
+#if     ((188 >= GSL_INCLUDER_FIRST_CASE) && (188 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (188)))
+#define  GSL_INCLUDER_CASE       188
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 189 */
+#if     ((189 >= GSL_INCLUDER_FIRST_CASE) && (189 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (189)))
+#define  GSL_INCLUDER_CASE       189
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 190 */
+#if     ((190 >= GSL_INCLUDER_FIRST_CASE) && (190 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (190)))
+#define  GSL_INCLUDER_CASE       190
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 191 */
+#if     ((191 >= GSL_INCLUDER_FIRST_CASE) && (191 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (191)))
+#define  GSL_INCLUDER_CASE       191
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 192 */
+#if     ((192 >= GSL_INCLUDER_FIRST_CASE) && (192 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (192)))
+#define  GSL_INCLUDER_CASE       192
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 193 */
+#if     ((193 >= GSL_INCLUDER_FIRST_CASE) && (193 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (193)))
+#define  GSL_INCLUDER_CASE       193
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 194 */
+#if     ((194 >= GSL_INCLUDER_FIRST_CASE) && (194 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (194)))
+#define  GSL_INCLUDER_CASE       194
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 195 */
+#if     ((195 >= GSL_INCLUDER_FIRST_CASE) && (195 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (195)))
+#define  GSL_INCLUDER_CASE       195
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 196 */
+#if     ((196 >= GSL_INCLUDER_FIRST_CASE) && (196 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (196)))
+#define  GSL_INCLUDER_CASE       196
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 197 */
+#if     ((197 >= GSL_INCLUDER_FIRST_CASE) && (197 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (197)))
+#define  GSL_INCLUDER_CASE       197
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 198 */
+#if     ((198 >= GSL_INCLUDER_FIRST_CASE) && (198 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (198)))
+#define  GSL_INCLUDER_CASE       198
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 199 */
+#if     ((199 >= GSL_INCLUDER_FIRST_CASE) && (199 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (199)))
+#define  GSL_INCLUDER_CASE       199
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 200 */
+#if     ((200 >= GSL_INCLUDER_FIRST_CASE) && (200 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (200)))
+#define  GSL_INCLUDER_CASE       200
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 201 */
+#if     ((201 >= GSL_INCLUDER_FIRST_CASE) && (201 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (201)))
+#define  GSL_INCLUDER_CASE       201
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 202 */
+#if     ((202 >= GSL_INCLUDER_FIRST_CASE) && (202 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (202)))
+#define  GSL_INCLUDER_CASE       202
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 203 */
+#if     ((203 >= GSL_INCLUDER_FIRST_CASE) && (203 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (203)))
+#define  GSL_INCLUDER_CASE       203
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 204 */
+#if     ((204 >= GSL_INCLUDER_FIRST_CASE) && (204 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (204)))
+#define  GSL_INCLUDER_CASE       204
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 205 */
+#if     ((205 >= GSL_INCLUDER_FIRST_CASE) && (205 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (205)))
+#define  GSL_INCLUDER_CASE       205
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 206 */
+#if     ((206 >= GSL_INCLUDER_FIRST_CASE) && (206 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (206)))
+#define  GSL_INCLUDER_CASE       206
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 207 */
+#if     ((207 >= GSL_INCLUDER_FIRST_CASE) && (207 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (207)))
+#define  GSL_INCLUDER_CASE       207
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 208 */
+#if     ((208 >= GSL_INCLUDER_FIRST_CASE) && (208 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (208)))
+#define  GSL_INCLUDER_CASE       208
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 209 */
+#if     ((209 >= GSL_INCLUDER_FIRST_CASE) && (209 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (209)))
+#define  GSL_INCLUDER_CASE       209
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 210 */
+#if     ((210 >= GSL_INCLUDER_FIRST_CASE) && (210 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (210)))
+#define  GSL_INCLUDER_CASE       210
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 211 */
+#if     ((211 >= GSL_INCLUDER_FIRST_CASE) && (211 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (211)))
+#define  GSL_INCLUDER_CASE       211
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 212 */
+#if     ((212 >= GSL_INCLUDER_FIRST_CASE) && (212 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (212)))
+#define  GSL_INCLUDER_CASE       212
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 213 */
+#if     ((213 >= GSL_INCLUDER_FIRST_CASE) && (213 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (213)))
+#define  GSL_INCLUDER_CASE       213
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 214 */
+#if     ((214 >= GSL_INCLUDER_FIRST_CASE) && (214 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (214)))
+#define  GSL_INCLUDER_CASE       214
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 215 */
+#if     ((215 >= GSL_INCLUDER_FIRST_CASE) && (215 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (215)))
+#define  GSL_INCLUDER_CASE       215
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 216 */
+#if     ((216 >= GSL_INCLUDER_FIRST_CASE) && (216 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (216)))
+#define  GSL_INCLUDER_CASE       216
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 217 */
+#if     ((217 >= GSL_INCLUDER_FIRST_CASE) && (217 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (217)))
+#define  GSL_INCLUDER_CASE       217
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 218 */
+#if     ((218 >= GSL_INCLUDER_FIRST_CASE) && (218 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (218)))
+#define  GSL_INCLUDER_CASE       218
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 219 */
+#if     ((219 >= GSL_INCLUDER_FIRST_CASE) && (219 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (219)))
+#define  GSL_INCLUDER_CASE       219
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 220 */
+#if     ((220 >= GSL_INCLUDER_FIRST_CASE) && (220 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (220)))
+#define  GSL_INCLUDER_CASE       220
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 221 */
+#if     ((221 >= GSL_INCLUDER_FIRST_CASE) && (221 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (221)))
+#define  GSL_INCLUDER_CASE       221
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 222 */
+#if     ((222 >= GSL_INCLUDER_FIRST_CASE) && (222 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (222)))
+#define  GSL_INCLUDER_CASE       222
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 223 */
+#if     ((223 >= GSL_INCLUDER_FIRST_CASE) && (223 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (223)))
+#define  GSL_INCLUDER_CASE       223
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 224 */
+#if     ((224 >= GSL_INCLUDER_FIRST_CASE) && (224 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (224)))
+#define  GSL_INCLUDER_CASE       224
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 225 */
+#if     ((225 >= GSL_INCLUDER_FIRST_CASE) && (225 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (225)))
+#define  GSL_INCLUDER_CASE       225
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 226 */
+#if     ((226 >= GSL_INCLUDER_FIRST_CASE) && (226 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (226)))
+#define  GSL_INCLUDER_CASE       226
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 227 */
+#if     ((227 >= GSL_INCLUDER_FIRST_CASE) && (227 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (227)))
+#define  GSL_INCLUDER_CASE       227
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 228 */
+#if     ((228 >= GSL_INCLUDER_FIRST_CASE) && (228 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (228)))
+#define  GSL_INCLUDER_CASE       228
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 229 */
+#if     ((229 >= GSL_INCLUDER_FIRST_CASE) && (229 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (229)))
+#define  GSL_INCLUDER_CASE       229
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 230 */
+#if     ((230 >= GSL_INCLUDER_FIRST_CASE) && (230 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (230)))
+#define  GSL_INCLUDER_CASE       230
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 231 */
+#if     ((231 >= GSL_INCLUDER_FIRST_CASE) && (231 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (231)))
+#define  GSL_INCLUDER_CASE       231
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 232 */
+#if     ((232 >= GSL_INCLUDER_FIRST_CASE) && (232 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (232)))
+#define  GSL_INCLUDER_CASE       232
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 233 */
+#if     ((233 >= GSL_INCLUDER_FIRST_CASE) && (233 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (233)))
+#define  GSL_INCLUDER_CASE       233
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 234 */
+#if     ((234 >= GSL_INCLUDER_FIRST_CASE) && (234 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (234)))
+#define  GSL_INCLUDER_CASE       234
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 235 */
+#if     ((235 >= GSL_INCLUDER_FIRST_CASE) && (235 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (235)))
+#define  GSL_INCLUDER_CASE       235
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 236 */
+#if     ((236 >= GSL_INCLUDER_FIRST_CASE) && (236 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (236)))
+#define  GSL_INCLUDER_CASE       236
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 237 */
+#if     ((237 >= GSL_INCLUDER_FIRST_CASE) && (237 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (237)))
+#define  GSL_INCLUDER_CASE       237
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 238 */
+#if     ((238 >= GSL_INCLUDER_FIRST_CASE) && (238 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (238)))
+#define  GSL_INCLUDER_CASE       238
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 239 */
+#if     ((239 >= GSL_INCLUDER_FIRST_CASE) && (239 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (239)))
+#define  GSL_INCLUDER_CASE       239
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 240 */
+#if     ((240 >= GSL_INCLUDER_FIRST_CASE) && (240 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (240)))
+#define  GSL_INCLUDER_CASE       240
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 241 */
+#if     ((241 >= GSL_INCLUDER_FIRST_CASE) && (241 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (241)))
+#define  GSL_INCLUDER_CASE       241
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 242 */
+#if     ((242 >= GSL_INCLUDER_FIRST_CASE) && (242 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (242)))
+#define  GSL_INCLUDER_CASE       242
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 243 */
+#if     ((243 >= GSL_INCLUDER_FIRST_CASE) && (243 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (243)))
+#define  GSL_INCLUDER_CASE       243
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 244 */
+#if     ((244 >= GSL_INCLUDER_FIRST_CASE) && (244 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (244)))
+#define  GSL_INCLUDER_CASE       244
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 245 */
+#if     ((245 >= GSL_INCLUDER_FIRST_CASE) && (245 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (245)))
+#define  GSL_INCLUDER_CASE       245
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 246 */
+#if     ((246 >= GSL_INCLUDER_FIRST_CASE) && (246 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (246)))
+#define  GSL_INCLUDER_CASE       246
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 247 */
+#if     ((247 >= GSL_INCLUDER_FIRST_CASE) && (247 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (247)))
+#define  GSL_INCLUDER_CASE       247
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 248 */
+#if     ((248 >= GSL_INCLUDER_FIRST_CASE) && (248 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (248)))
+#define  GSL_INCLUDER_CASE       248
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 249 */
+#if     ((249 >= GSL_INCLUDER_FIRST_CASE) && (249 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (249)))
+#define  GSL_INCLUDER_CASE       249
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 250 */
+#if     ((250 >= GSL_INCLUDER_FIRST_CASE) && (250 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (250)))
+#define  GSL_INCLUDER_CASE       250
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 251 */
+#if     ((251 >= GSL_INCLUDER_FIRST_CASE) && (251 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (251)))
+#define  GSL_INCLUDER_CASE       251
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 252 */
+#if     ((252 >= GSL_INCLUDER_FIRST_CASE) && (252 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (252)))
+#define  GSL_INCLUDER_CASE       252
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 253 */
+#if     ((253 >= GSL_INCLUDER_FIRST_CASE) && (253 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (253)))
+#define  GSL_INCLUDER_CASE       253
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 254 */
+#if     ((254 >= GSL_INCLUDER_FIRST_CASE) && (254 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (254)))
+#define  GSL_INCLUDER_CASE       254
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 255 */
+#if     ((255 >= GSL_INCLUDER_FIRST_CASE) && (255 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (255)))
+#define  GSL_INCLUDER_CASE       255
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 256 */
+#if     ((256 >= GSL_INCLUDER_FIRST_CASE) && (256 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (256)))
+#define  GSL_INCLUDER_CASE       256
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 257 */
+#if     ((257 >= GSL_INCLUDER_FIRST_CASE) && (257 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (257)))
+#define  GSL_INCLUDER_CASE       257
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 258 */
+#if     ((258 >= GSL_INCLUDER_FIRST_CASE) && (258 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (258)))
+#define  GSL_INCLUDER_CASE       258
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 259 */
+#if     ((259 >= GSL_INCLUDER_FIRST_CASE) && (259 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (259)))
+#define  GSL_INCLUDER_CASE       259
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 260 */
+#if     ((260 >= GSL_INCLUDER_FIRST_CASE) && (260 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (260)))
+#define  GSL_INCLUDER_CASE       260
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 261 */
+#if     ((261 >= GSL_INCLUDER_FIRST_CASE) && (261 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (261)))
+#define  GSL_INCLUDER_CASE       261
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 262 */
+#if     ((262 >= GSL_INCLUDER_FIRST_CASE) && (262 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (262)))
+#define  GSL_INCLUDER_CASE       262
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 263 */
+#if     ((263 >= GSL_INCLUDER_FIRST_CASE) && (263 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (263)))
+#define  GSL_INCLUDER_CASE       263
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 264 */
+#if     ((264 >= GSL_INCLUDER_FIRST_CASE) && (264 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (264)))
+#define  GSL_INCLUDER_CASE       264
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 265 */
+#if     ((265 >= GSL_INCLUDER_FIRST_CASE) && (265 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (265)))
+#define  GSL_INCLUDER_CASE       265
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 266 */
+#if     ((266 >= GSL_INCLUDER_FIRST_CASE) && (266 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (266)))
+#define  GSL_INCLUDER_CASE       266
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 267 */
+#if     ((267 >= GSL_INCLUDER_FIRST_CASE) && (267 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (267)))
+#define  GSL_INCLUDER_CASE       267
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 268 */
+#if     ((268 >= GSL_INCLUDER_FIRST_CASE) && (268 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (268)))
+#define  GSL_INCLUDER_CASE       268
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 269 */
+#if     ((269 >= GSL_INCLUDER_FIRST_CASE) && (269 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (269)))
+#define  GSL_INCLUDER_CASE       269
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 270 */
+#if     ((270 >= GSL_INCLUDER_FIRST_CASE) && (270 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (270)))
+#define  GSL_INCLUDER_CASE       270
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 271 */
+#if     ((271 >= GSL_INCLUDER_FIRST_CASE) && (271 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (271)))
+#define  GSL_INCLUDER_CASE       271
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 272 */
+#if     ((272 >= GSL_INCLUDER_FIRST_CASE) && (272 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (272)))
+#define  GSL_INCLUDER_CASE       272
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 273 */
+#if     ((273 >= GSL_INCLUDER_FIRST_CASE) && (273 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (273)))
+#define  GSL_INCLUDER_CASE       273
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 274 */
+#if     ((274 >= GSL_INCLUDER_FIRST_CASE) && (274 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (274)))
+#define  GSL_INCLUDER_CASE       274
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 275 */
+#if     ((275 >= GSL_INCLUDER_FIRST_CASE) && (275 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (275)))
+#define  GSL_INCLUDER_CASE       275
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 276 */
+#if     ((276 >= GSL_INCLUDER_FIRST_CASE) && (276 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (276)))
+#define  GSL_INCLUDER_CASE       276
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 277 */
+#if     ((277 >= GSL_INCLUDER_FIRST_CASE) && (277 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (277)))
+#define  GSL_INCLUDER_CASE       277
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 278 */
+#if     ((278 >= GSL_INCLUDER_FIRST_CASE) && (278 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (278)))
+#define  GSL_INCLUDER_CASE       278
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 279 */
+#if     ((279 >= GSL_INCLUDER_FIRST_CASE) && (279 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (279)))
+#define  GSL_INCLUDER_CASE       279
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 280 */
+#if     ((280 >= GSL_INCLUDER_FIRST_CASE) && (280 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (280)))
+#define  GSL_INCLUDER_CASE       280
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 281 */
+#if     ((281 >= GSL_INCLUDER_FIRST_CASE) && (281 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (281)))
+#define  GSL_INCLUDER_CASE       281
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 282 */
+#if     ((282 >= GSL_INCLUDER_FIRST_CASE) && (282 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (282)))
+#define  GSL_INCLUDER_CASE       282
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 283 */
+#if     ((283 >= GSL_INCLUDER_FIRST_CASE) && (283 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (283)))
+#define  GSL_INCLUDER_CASE       283
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 284 */
+#if     ((284 >= GSL_INCLUDER_FIRST_CASE) && (284 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (284)))
+#define  GSL_INCLUDER_CASE       284
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 285 */
+#if     ((285 >= GSL_INCLUDER_FIRST_CASE) && (285 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (285)))
+#define  GSL_INCLUDER_CASE       285
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 286 */
+#if     ((286 >= GSL_INCLUDER_FIRST_CASE) && (286 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (286)))
+#define  GSL_INCLUDER_CASE       286
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 287 */
+#if     ((287 >= GSL_INCLUDER_FIRST_CASE) && (287 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (287)))
+#define  GSL_INCLUDER_CASE       287
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 288 */
+#if     ((288 >= GSL_INCLUDER_FIRST_CASE) && (288 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (288)))
+#define  GSL_INCLUDER_CASE       288
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 289 */
+#if     ((289 >= GSL_INCLUDER_FIRST_CASE) && (289 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (289)))
+#define  GSL_INCLUDER_CASE       289
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 290 */
+#if     ((290 >= GSL_INCLUDER_FIRST_CASE) && (290 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (290)))
+#define  GSL_INCLUDER_CASE       290
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 291 */
+#if     ((291 >= GSL_INCLUDER_FIRST_CASE) && (291 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (291)))
+#define  GSL_INCLUDER_CASE       291
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 292 */
+#if     ((292 >= GSL_INCLUDER_FIRST_CASE) && (292 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (292)))
+#define  GSL_INCLUDER_CASE       292
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 293 */
+#if     ((293 >= GSL_INCLUDER_FIRST_CASE) && (293 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (293)))
+#define  GSL_INCLUDER_CASE       293
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 294 */
+#if     ((294 >= GSL_INCLUDER_FIRST_CASE) && (294 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (294)))
+#define  GSL_INCLUDER_CASE       294
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 295 */
+#if     ((295 >= GSL_INCLUDER_FIRST_CASE) && (295 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (295)))
+#define  GSL_INCLUDER_CASE       295
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 296 */
+#if     ((296 >= GSL_INCLUDER_FIRST_CASE) && (296 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (296)))
+#define  GSL_INCLUDER_CASE       296
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 297 */
+#if     ((297 >= GSL_INCLUDER_FIRST_CASE) && (297 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (297)))
+#define  GSL_INCLUDER_CASE       297
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 298 */
+#if     ((298 >= GSL_INCLUDER_FIRST_CASE) && (298 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (298)))
+#define  GSL_INCLUDER_CASE       298
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 299 */
+#if     ((299 >= GSL_INCLUDER_FIRST_CASE) && (299 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (299)))
+#define  GSL_INCLUDER_CASE       299
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 300 */
+#if     ((300 >= GSL_INCLUDER_FIRST_CASE) && (300 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (300)))
+#define  GSL_INCLUDER_CASE       300
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 301 */
+#if     ((301 >= GSL_INCLUDER_FIRST_CASE) && (301 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (301)))
+#define  GSL_INCLUDER_CASE       301
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 302 */
+#if     ((302 >= GSL_INCLUDER_FIRST_CASE) && (302 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (302)))
+#define  GSL_INCLUDER_CASE       302
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 303 */
+#if     ((303 >= GSL_INCLUDER_FIRST_CASE) && (303 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (303)))
+#define  GSL_INCLUDER_CASE       303
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 304 */
+#if     ((304 >= GSL_INCLUDER_FIRST_CASE) && (304 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (304)))
+#define  GSL_INCLUDER_CASE       304
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 305 */
+#if     ((305 >= GSL_INCLUDER_FIRST_CASE) && (305 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (305)))
+#define  GSL_INCLUDER_CASE       305
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 306 */
+#if     ((306 >= GSL_INCLUDER_FIRST_CASE) && (306 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (306)))
+#define  GSL_INCLUDER_CASE       306
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 307 */
+#if     ((307 >= GSL_INCLUDER_FIRST_CASE) && (307 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (307)))
+#define  GSL_INCLUDER_CASE       307
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 308 */
+#if     ((308 >= GSL_INCLUDER_FIRST_CASE) && (308 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (308)))
+#define  GSL_INCLUDER_CASE       308
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 309 */
+#if     ((309 >= GSL_INCLUDER_FIRST_CASE) && (309 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (309)))
+#define  GSL_INCLUDER_CASE       309
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 310 */
+#if     ((310 >= GSL_INCLUDER_FIRST_CASE) && (310 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (310)))
+#define  GSL_INCLUDER_CASE       310
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 311 */
+#if     ((311 >= GSL_INCLUDER_FIRST_CASE) && (311 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (311)))
+#define  GSL_INCLUDER_CASE       311
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 312 */
+#if     ((312 >= GSL_INCLUDER_FIRST_CASE) && (312 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (312)))
+#define  GSL_INCLUDER_CASE       312
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 313 */
+#if     ((313 >= GSL_INCLUDER_FIRST_CASE) && (313 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (313)))
+#define  GSL_INCLUDER_CASE       313
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 314 */
+#if     ((314 >= GSL_INCLUDER_FIRST_CASE) && (314 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (314)))
+#define  GSL_INCLUDER_CASE       314
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 315 */
+#if     ((315 >= GSL_INCLUDER_FIRST_CASE) && (315 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (315)))
+#define  GSL_INCLUDER_CASE       315
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 316 */
+#if     ((316 >= GSL_INCLUDER_FIRST_CASE) && (316 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (316)))
+#define  GSL_INCLUDER_CASE       316
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 317 */
+#if     ((317 >= GSL_INCLUDER_FIRST_CASE) && (317 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (317)))
+#define  GSL_INCLUDER_CASE       317
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 318 */
+#if     ((318 >= GSL_INCLUDER_FIRST_CASE) && (318 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (318)))
+#define  GSL_INCLUDER_CASE       318
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 319 */
+#if     ((319 >= GSL_INCLUDER_FIRST_CASE) && (319 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (319)))
+#define  GSL_INCLUDER_CASE       319
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 320 */
+#if     ((320 >= GSL_INCLUDER_FIRST_CASE) && (320 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (320)))
+#define  GSL_INCLUDER_CASE       320
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 321 */
+#if     ((321 >= GSL_INCLUDER_FIRST_CASE) && (321 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (321)))
+#define  GSL_INCLUDER_CASE       321
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 322 */
+#if     ((322 >= GSL_INCLUDER_FIRST_CASE) && (322 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (322)))
+#define  GSL_INCLUDER_CASE       322
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 323 */
+#if     ((323 >= GSL_INCLUDER_FIRST_CASE) && (323 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (323)))
+#define  GSL_INCLUDER_CASE       323
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 324 */
+#if     ((324 >= GSL_INCLUDER_FIRST_CASE) && (324 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (324)))
+#define  GSL_INCLUDER_CASE       324
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 325 */
+#if     ((325 >= GSL_INCLUDER_FIRST_CASE) && (325 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (325)))
+#define  GSL_INCLUDER_CASE       325
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 326 */
+#if     ((326 >= GSL_INCLUDER_FIRST_CASE) && (326 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (326)))
+#define  GSL_INCLUDER_CASE       326
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 327 */
+#if     ((327 >= GSL_INCLUDER_FIRST_CASE) && (327 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (327)))
+#define  GSL_INCLUDER_CASE       327
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 328 */
+#if     ((328 >= GSL_INCLUDER_FIRST_CASE) && (328 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (328)))
+#define  GSL_INCLUDER_CASE       328
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 329 */
+#if     ((329 >= GSL_INCLUDER_FIRST_CASE) && (329 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (329)))
+#define  GSL_INCLUDER_CASE       329
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 330 */
+#if     ((330 >= GSL_INCLUDER_FIRST_CASE) && (330 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (330)))
+#define  GSL_INCLUDER_CASE       330
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 331 */
+#if     ((331 >= GSL_INCLUDER_FIRST_CASE) && (331 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (331)))
+#define  GSL_INCLUDER_CASE       331
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 332 */
+#if     ((332 >= GSL_INCLUDER_FIRST_CASE) && (332 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (332)))
+#define  GSL_INCLUDER_CASE       332
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 333 */
+#if     ((333 >= GSL_INCLUDER_FIRST_CASE) && (333 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (333)))
+#define  GSL_INCLUDER_CASE       333
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 334 */
+#if     ((334 >= GSL_INCLUDER_FIRST_CASE) && (334 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (334)))
+#define  GSL_INCLUDER_CASE       334
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 335 */
+#if     ((335 >= GSL_INCLUDER_FIRST_CASE) && (335 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (335)))
+#define  GSL_INCLUDER_CASE       335
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 336 */
+#if     ((336 >= GSL_INCLUDER_FIRST_CASE) && (336 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (336)))
+#define  GSL_INCLUDER_CASE       336
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 337 */
+#if     ((337 >= GSL_INCLUDER_FIRST_CASE) && (337 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (337)))
+#define  GSL_INCLUDER_CASE       337
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 338 */
+#if     ((338 >= GSL_INCLUDER_FIRST_CASE) && (338 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (338)))
+#define  GSL_INCLUDER_CASE       338
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 339 */
+#if     ((339 >= GSL_INCLUDER_FIRST_CASE) && (339 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (339)))
+#define  GSL_INCLUDER_CASE       339
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 340 */
+#if     ((340 >= GSL_INCLUDER_FIRST_CASE) && (340 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (340)))
+#define  GSL_INCLUDER_CASE       340
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 341 */
+#if     ((341 >= GSL_INCLUDER_FIRST_CASE) && (341 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (341)))
+#define  GSL_INCLUDER_CASE       341
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 342 */
+#if     ((342 >= GSL_INCLUDER_FIRST_CASE) && (342 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (342)))
+#define  GSL_INCLUDER_CASE       342
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 343 */
+#if     ((343 >= GSL_INCLUDER_FIRST_CASE) && (343 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (343)))
+#define  GSL_INCLUDER_CASE       343
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 344 */
+#if     ((344 >= GSL_INCLUDER_FIRST_CASE) && (344 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (344)))
+#define  GSL_INCLUDER_CASE       344
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 345 */
+#if     ((345 >= GSL_INCLUDER_FIRST_CASE) && (345 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (345)))
+#define  GSL_INCLUDER_CASE       345
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 346 */
+#if     ((346 >= GSL_INCLUDER_FIRST_CASE) && (346 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (346)))
+#define  GSL_INCLUDER_CASE       346
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 347 */
+#if     ((347 >= GSL_INCLUDER_FIRST_CASE) && (347 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (347)))
+#define  GSL_INCLUDER_CASE       347
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 348 */
+#if     ((348 >= GSL_INCLUDER_FIRST_CASE) && (348 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (348)))
+#define  GSL_INCLUDER_CASE       348
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 349 */
+#if     ((349 >= GSL_INCLUDER_FIRST_CASE) && (349 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (349)))
+#define  GSL_INCLUDER_CASE       349
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 350 */
+#if     ((350 >= GSL_INCLUDER_FIRST_CASE) && (350 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (350)))
+#define  GSL_INCLUDER_CASE       350
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 351 */
+#if     ((351 >= GSL_INCLUDER_FIRST_CASE) && (351 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (351)))
+#define  GSL_INCLUDER_CASE       351
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 352 */
+#if     ((352 >= GSL_INCLUDER_FIRST_CASE) && (352 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (352)))
+#define  GSL_INCLUDER_CASE       352
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 353 */
+#if     ((353 >= GSL_INCLUDER_FIRST_CASE) && (353 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (353)))
+#define  GSL_INCLUDER_CASE       353
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 354 */
+#if     ((354 >= GSL_INCLUDER_FIRST_CASE) && (354 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (354)))
+#define  GSL_INCLUDER_CASE       354
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 355 */
+#if     ((355 >= GSL_INCLUDER_FIRST_CASE) && (355 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (355)))
+#define  GSL_INCLUDER_CASE       355
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 356 */
+#if     ((356 >= GSL_INCLUDER_FIRST_CASE) && (356 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (356)))
+#define  GSL_INCLUDER_CASE       356
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 357 */
+#if     ((357 >= GSL_INCLUDER_FIRST_CASE) && (357 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (357)))
+#define  GSL_INCLUDER_CASE       357
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 358 */
+#if     ((358 >= GSL_INCLUDER_FIRST_CASE) && (358 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (358)))
+#define  GSL_INCLUDER_CASE       358
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 359 */
+#if     ((359 >= GSL_INCLUDER_FIRST_CASE) && (359 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (359)))
+#define  GSL_INCLUDER_CASE       359
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 360 */
+#if     ((360 >= GSL_INCLUDER_FIRST_CASE) && (360 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (360)))
+#define  GSL_INCLUDER_CASE       360
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 361 */
+#if     ((361 >= GSL_INCLUDER_FIRST_CASE) && (361 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (361)))
+#define  GSL_INCLUDER_CASE       361
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 362 */
+#if     ((362 >= GSL_INCLUDER_FIRST_CASE) && (362 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (362)))
+#define  GSL_INCLUDER_CASE       362
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 363 */
+#if     ((363 >= GSL_INCLUDER_FIRST_CASE) && (363 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (363)))
+#define  GSL_INCLUDER_CASE       363
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 364 */
+#if     ((364 >= GSL_INCLUDER_FIRST_CASE) && (364 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (364)))
+#define  GSL_INCLUDER_CASE       364
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 365 */
+#if     ((365 >= GSL_INCLUDER_FIRST_CASE) && (365 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (365)))
+#define  GSL_INCLUDER_CASE       365
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 366 */
+#if     ((366 >= GSL_INCLUDER_FIRST_CASE) && (366 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (366)))
+#define  GSL_INCLUDER_CASE       366
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 367 */
+#if     ((367 >= GSL_INCLUDER_FIRST_CASE) && (367 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (367)))
+#define  GSL_INCLUDER_CASE       367
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 368 */
+#if     ((368 >= GSL_INCLUDER_FIRST_CASE) && (368 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (368)))
+#define  GSL_INCLUDER_CASE       368
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 369 */
+#if     ((369 >= GSL_INCLUDER_FIRST_CASE) && (369 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (369)))
+#define  GSL_INCLUDER_CASE       369
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 370 */
+#if     ((370 >= GSL_INCLUDER_FIRST_CASE) && (370 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (370)))
+#define  GSL_INCLUDER_CASE       370
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 371 */
+#if     ((371 >= GSL_INCLUDER_FIRST_CASE) && (371 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (371)))
+#define  GSL_INCLUDER_CASE       371
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 372 */
+#if     ((372 >= GSL_INCLUDER_FIRST_CASE) && (372 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (372)))
+#define  GSL_INCLUDER_CASE       372
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 373 */
+#if     ((373 >= GSL_INCLUDER_FIRST_CASE) && (373 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (373)))
+#define  GSL_INCLUDER_CASE       373
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 374 */
+#if     ((374 >= GSL_INCLUDER_FIRST_CASE) && (374 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (374)))
+#define  GSL_INCLUDER_CASE       374
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 375 */
+#if     ((375 >= GSL_INCLUDER_FIRST_CASE) && (375 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (375)))
+#define  GSL_INCLUDER_CASE       375
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 376 */
+#if     ((376 >= GSL_INCLUDER_FIRST_CASE) && (376 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (376)))
+#define  GSL_INCLUDER_CASE       376
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 377 */
+#if     ((377 >= GSL_INCLUDER_FIRST_CASE) && (377 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (377)))
+#define  GSL_INCLUDER_CASE       377
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 378 */
+#if     ((378 >= GSL_INCLUDER_FIRST_CASE) && (378 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (378)))
+#define  GSL_INCLUDER_CASE       378
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 379 */
+#if     ((379 >= GSL_INCLUDER_FIRST_CASE) && (379 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (379)))
+#define  GSL_INCLUDER_CASE       379
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 380 */
+#if     ((380 >= GSL_INCLUDER_FIRST_CASE) && (380 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (380)))
+#define  GSL_INCLUDER_CASE       380
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 381 */
+#if     ((381 >= GSL_INCLUDER_FIRST_CASE) && (381 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (381)))
+#define  GSL_INCLUDER_CASE       381
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 382 */
+#if     ((382 >= GSL_INCLUDER_FIRST_CASE) && (382 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (382)))
+#define  GSL_INCLUDER_CASE       382
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 383 */
+#if     ((383 >= GSL_INCLUDER_FIRST_CASE) && (383 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (383)))
+#define  GSL_INCLUDER_CASE       383
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 384 */
+#if     ((384 >= GSL_INCLUDER_FIRST_CASE) && (384 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (384)))
+#define  GSL_INCLUDER_CASE       384
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 385 */
+#if     ((385 >= GSL_INCLUDER_FIRST_CASE) && (385 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (385)))
+#define  GSL_INCLUDER_CASE       385
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 386 */
+#if     ((386 >= GSL_INCLUDER_FIRST_CASE) && (386 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (386)))
+#define  GSL_INCLUDER_CASE       386
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 387 */
+#if     ((387 >= GSL_INCLUDER_FIRST_CASE) && (387 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (387)))
+#define  GSL_INCLUDER_CASE       387
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 388 */
+#if     ((388 >= GSL_INCLUDER_FIRST_CASE) && (388 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (388)))
+#define  GSL_INCLUDER_CASE       388
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 389 */
+#if     ((389 >= GSL_INCLUDER_FIRST_CASE) && (389 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (389)))
+#define  GSL_INCLUDER_CASE       389
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 390 */
+#if     ((390 >= GSL_INCLUDER_FIRST_CASE) && (390 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (390)))
+#define  GSL_INCLUDER_CASE       390
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 391 */
+#if     ((391 >= GSL_INCLUDER_FIRST_CASE) && (391 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (391)))
+#define  GSL_INCLUDER_CASE       391
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 392 */
+#if     ((392 >= GSL_INCLUDER_FIRST_CASE) && (392 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (392)))
+#define  GSL_INCLUDER_CASE       392
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 393 */
+#if     ((393 >= GSL_INCLUDER_FIRST_CASE) && (393 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (393)))
+#define  GSL_INCLUDER_CASE       393
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 394 */
+#if     ((394 >= GSL_INCLUDER_FIRST_CASE) && (394 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (394)))
+#define  GSL_INCLUDER_CASE       394
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 395 */
+#if     ((395 >= GSL_INCLUDER_FIRST_CASE) && (395 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (395)))
+#define  GSL_INCLUDER_CASE       395
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 396 */
+#if     ((396 >= GSL_INCLUDER_FIRST_CASE) && (396 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (396)))
+#define  GSL_INCLUDER_CASE       396
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 397 */
+#if     ((397 >= GSL_INCLUDER_FIRST_CASE) && (397 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (397)))
+#define  GSL_INCLUDER_CASE       397
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 398 */
+#if     ((398 >= GSL_INCLUDER_FIRST_CASE) && (398 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (398)))
+#define  GSL_INCLUDER_CASE       398
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 399 */
+#if     ((399 >= GSL_INCLUDER_FIRST_CASE) && (399 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (399)))
+#define  GSL_INCLUDER_CASE       399
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 400 */
+#if     ((400 >= GSL_INCLUDER_FIRST_CASE) && (400 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (400)))
+#define  GSL_INCLUDER_CASE       400
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 401 */
+#if     ((401 >= GSL_INCLUDER_FIRST_CASE) && (401 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (401)))
+#define  GSL_INCLUDER_CASE       401
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 402 */
+#if     ((402 >= GSL_INCLUDER_FIRST_CASE) && (402 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (402)))
+#define  GSL_INCLUDER_CASE       402
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 403 */
+#if     ((403 >= GSL_INCLUDER_FIRST_CASE) && (403 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (403)))
+#define  GSL_INCLUDER_CASE       403
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 404 */
+#if     ((404 >= GSL_INCLUDER_FIRST_CASE) && (404 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (404)))
+#define  GSL_INCLUDER_CASE       404
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 405 */
+#if     ((405 >= GSL_INCLUDER_FIRST_CASE) && (405 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (405)))
+#define  GSL_INCLUDER_CASE       405
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 406 */
+#if     ((406 >= GSL_INCLUDER_FIRST_CASE) && (406 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (406)))
+#define  GSL_INCLUDER_CASE       406
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 407 */
+#if     ((407 >= GSL_INCLUDER_FIRST_CASE) && (407 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (407)))
+#define  GSL_INCLUDER_CASE       407
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 408 */
+#if     ((408 >= GSL_INCLUDER_FIRST_CASE) && (408 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (408)))
+#define  GSL_INCLUDER_CASE       408
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 409 */
+#if     ((409 >= GSL_INCLUDER_FIRST_CASE) && (409 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (409)))
+#define  GSL_INCLUDER_CASE       409
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 410 */
+#if     ((410 >= GSL_INCLUDER_FIRST_CASE) && (410 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (410)))
+#define  GSL_INCLUDER_CASE       410
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 411 */
+#if     ((411 >= GSL_INCLUDER_FIRST_CASE) && (411 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (411)))
+#define  GSL_INCLUDER_CASE       411
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 412 */
+#if     ((412 >= GSL_INCLUDER_FIRST_CASE) && (412 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (412)))
+#define  GSL_INCLUDER_CASE       412
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 413 */
+#if     ((413 >= GSL_INCLUDER_FIRST_CASE) && (413 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (413)))
+#define  GSL_INCLUDER_CASE       413
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 414 */
+#if     ((414 >= GSL_INCLUDER_FIRST_CASE) && (414 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (414)))
+#define  GSL_INCLUDER_CASE       414
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 415 */
+#if     ((415 >= GSL_INCLUDER_FIRST_CASE) && (415 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (415)))
+#define  GSL_INCLUDER_CASE       415
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 416 */
+#if     ((416 >= GSL_INCLUDER_FIRST_CASE) && (416 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (416)))
+#define  GSL_INCLUDER_CASE       416
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 417 */
+#if     ((417 >= GSL_INCLUDER_FIRST_CASE) && (417 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (417)))
+#define  GSL_INCLUDER_CASE       417
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 418 */
+#if     ((418 >= GSL_INCLUDER_FIRST_CASE) && (418 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (418)))
+#define  GSL_INCLUDER_CASE       418
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 419 */
+#if     ((419 >= GSL_INCLUDER_FIRST_CASE) && (419 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (419)))
+#define  GSL_INCLUDER_CASE       419
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 420 */
+#if     ((420 >= GSL_INCLUDER_FIRST_CASE) && (420 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (420)))
+#define  GSL_INCLUDER_CASE       420
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 421 */
+#if     ((421 >= GSL_INCLUDER_FIRST_CASE) && (421 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (421)))
+#define  GSL_INCLUDER_CASE       421
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 422 */
+#if     ((422 >= GSL_INCLUDER_FIRST_CASE) && (422 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (422)))
+#define  GSL_INCLUDER_CASE       422
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 423 */
+#if     ((423 >= GSL_INCLUDER_FIRST_CASE) && (423 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (423)))
+#define  GSL_INCLUDER_CASE       423
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 424 */
+#if     ((424 >= GSL_INCLUDER_FIRST_CASE) && (424 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (424)))
+#define  GSL_INCLUDER_CASE       424
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 425 */
+#if     ((425 >= GSL_INCLUDER_FIRST_CASE) && (425 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (425)))
+#define  GSL_INCLUDER_CASE       425
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 426 */
+#if     ((426 >= GSL_INCLUDER_FIRST_CASE) && (426 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (426)))
+#define  GSL_INCLUDER_CASE       426
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 427 */
+#if     ((427 >= GSL_INCLUDER_FIRST_CASE) && (427 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (427)))
+#define  GSL_INCLUDER_CASE       427
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 428 */
+#if     ((428 >= GSL_INCLUDER_FIRST_CASE) && (428 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (428)))
+#define  GSL_INCLUDER_CASE       428
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 429 */
+#if     ((429 >= GSL_INCLUDER_FIRST_CASE) && (429 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (429)))
+#define  GSL_INCLUDER_CASE       429
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 430 */
+#if     ((430 >= GSL_INCLUDER_FIRST_CASE) && (430 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (430)))
+#define  GSL_INCLUDER_CASE       430
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 431 */
+#if     ((431 >= GSL_INCLUDER_FIRST_CASE) && (431 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (431)))
+#define  GSL_INCLUDER_CASE       431
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 432 */
+#if     ((432 >= GSL_INCLUDER_FIRST_CASE) && (432 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (432)))
+#define  GSL_INCLUDER_CASE       432
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 433 */
+#if     ((433 >= GSL_INCLUDER_FIRST_CASE) && (433 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (433)))
+#define  GSL_INCLUDER_CASE       433
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 434 */
+#if     ((434 >= GSL_INCLUDER_FIRST_CASE) && (434 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (434)))
+#define  GSL_INCLUDER_CASE       434
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 435 */
+#if     ((435 >= GSL_INCLUDER_FIRST_CASE) && (435 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (435)))
+#define  GSL_INCLUDER_CASE       435
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 436 */
+#if     ((436 >= GSL_INCLUDER_FIRST_CASE) && (436 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (436)))
+#define  GSL_INCLUDER_CASE       436
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 437 */
+#if     ((437 >= GSL_INCLUDER_FIRST_CASE) && (437 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (437)))
+#define  GSL_INCLUDER_CASE       437
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 438 */
+#if     ((438 >= GSL_INCLUDER_FIRST_CASE) && (438 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (438)))
+#define  GSL_INCLUDER_CASE       438
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 439 */
+#if     ((439 >= GSL_INCLUDER_FIRST_CASE) && (439 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (439)))
+#define  GSL_INCLUDER_CASE       439
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 440 */
+#if     ((440 >= GSL_INCLUDER_FIRST_CASE) && (440 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (440)))
+#define  GSL_INCLUDER_CASE       440
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 441 */
+#if     ((441 >= GSL_INCLUDER_FIRST_CASE) && (441 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (441)))
+#define  GSL_INCLUDER_CASE       441
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 442 */
+#if     ((442 >= GSL_INCLUDER_FIRST_CASE) && (442 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (442)))
+#define  GSL_INCLUDER_CASE       442
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 443 */
+#if     ((443 >= GSL_INCLUDER_FIRST_CASE) && (443 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (443)))
+#define  GSL_INCLUDER_CASE       443
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 444 */
+#if     ((444 >= GSL_INCLUDER_FIRST_CASE) && (444 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (444)))
+#define  GSL_INCLUDER_CASE       444
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 445 */
+#if     ((445 >= GSL_INCLUDER_FIRST_CASE) && (445 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (445)))
+#define  GSL_INCLUDER_CASE       445
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 446 */
+#if     ((446 >= GSL_INCLUDER_FIRST_CASE) && (446 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (446)))
+#define  GSL_INCLUDER_CASE       446
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 447 */
+#if     ((447 >= GSL_INCLUDER_FIRST_CASE) && (447 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (447)))
+#define  GSL_INCLUDER_CASE       447
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 448 */
+#if     ((448 >= GSL_INCLUDER_FIRST_CASE) && (448 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (448)))
+#define  GSL_INCLUDER_CASE       448
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 449 */
+#if     ((449 >= GSL_INCLUDER_FIRST_CASE) && (449 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (449)))
+#define  GSL_INCLUDER_CASE       449
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 450 */
+#if     ((450 >= GSL_INCLUDER_FIRST_CASE) && (450 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (450)))
+#define  GSL_INCLUDER_CASE       450
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 451 */
+#if     ((451 >= GSL_INCLUDER_FIRST_CASE) && (451 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (451)))
+#define  GSL_INCLUDER_CASE       451
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 452 */
+#if     ((452 >= GSL_INCLUDER_FIRST_CASE) && (452 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (452)))
+#define  GSL_INCLUDER_CASE       452
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 453 */
+#if     ((453 >= GSL_INCLUDER_FIRST_CASE) && (453 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (453)))
+#define  GSL_INCLUDER_CASE       453
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 454 */
+#if     ((454 >= GSL_INCLUDER_FIRST_CASE) && (454 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (454)))
+#define  GSL_INCLUDER_CASE       454
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 455 */
+#if     ((455 >= GSL_INCLUDER_FIRST_CASE) && (455 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (455)))
+#define  GSL_INCLUDER_CASE       455
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 456 */
+#if     ((456 >= GSL_INCLUDER_FIRST_CASE) && (456 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (456)))
+#define  GSL_INCLUDER_CASE       456
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 457 */
+#if     ((457 >= GSL_INCLUDER_FIRST_CASE) && (457 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (457)))
+#define  GSL_INCLUDER_CASE       457
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 458 */
+#if     ((458 >= GSL_INCLUDER_FIRST_CASE) && (458 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (458)))
+#define  GSL_INCLUDER_CASE       458
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 459 */
+#if     ((459 >= GSL_INCLUDER_FIRST_CASE) && (459 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (459)))
+#define  GSL_INCLUDER_CASE       459
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 460 */
+#if     ((460 >= GSL_INCLUDER_FIRST_CASE) && (460 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (460)))
+#define  GSL_INCLUDER_CASE       460
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 461 */
+#if     ((461 >= GSL_INCLUDER_FIRST_CASE) && (461 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (461)))
+#define  GSL_INCLUDER_CASE       461
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 462 */
+#if     ((462 >= GSL_INCLUDER_FIRST_CASE) && (462 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (462)))
+#define  GSL_INCLUDER_CASE       462
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 463 */
+#if     ((463 >= GSL_INCLUDER_FIRST_CASE) && (463 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (463)))
+#define  GSL_INCLUDER_CASE       463
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 464 */
+#if     ((464 >= GSL_INCLUDER_FIRST_CASE) && (464 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (464)))
+#define  GSL_INCLUDER_CASE       464
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 465 */
+#if     ((465 >= GSL_INCLUDER_FIRST_CASE) && (465 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (465)))
+#define  GSL_INCLUDER_CASE       465
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 466 */
+#if     ((466 >= GSL_INCLUDER_FIRST_CASE) && (466 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (466)))
+#define  GSL_INCLUDER_CASE       466
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 467 */
+#if     ((467 >= GSL_INCLUDER_FIRST_CASE) && (467 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (467)))
+#define  GSL_INCLUDER_CASE       467
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 468 */
+#if     ((468 >= GSL_INCLUDER_FIRST_CASE) && (468 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (468)))
+#define  GSL_INCLUDER_CASE       468
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 469 */
+#if     ((469 >= GSL_INCLUDER_FIRST_CASE) && (469 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (469)))
+#define  GSL_INCLUDER_CASE       469
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 470 */
+#if     ((470 >= GSL_INCLUDER_FIRST_CASE) && (470 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (470)))
+#define  GSL_INCLUDER_CASE       470
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 471 */
+#if     ((471 >= GSL_INCLUDER_FIRST_CASE) && (471 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (471)))
+#define  GSL_INCLUDER_CASE       471
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 472 */
+#if     ((472 >= GSL_INCLUDER_FIRST_CASE) && (472 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (472)))
+#define  GSL_INCLUDER_CASE       472
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 473 */
+#if     ((473 >= GSL_INCLUDER_FIRST_CASE) && (473 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (473)))
+#define  GSL_INCLUDER_CASE       473
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 474 */
+#if     ((474 >= GSL_INCLUDER_FIRST_CASE) && (474 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (474)))
+#define  GSL_INCLUDER_CASE       474
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 475 */
+#if     ((475 >= GSL_INCLUDER_FIRST_CASE) && (475 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (475)))
+#define  GSL_INCLUDER_CASE       475
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 476 */
+#if     ((476 >= GSL_INCLUDER_FIRST_CASE) && (476 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (476)))
+#define  GSL_INCLUDER_CASE       476
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 477 */
+#if     ((477 >= GSL_INCLUDER_FIRST_CASE) && (477 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (477)))
+#define  GSL_INCLUDER_CASE       477
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 478 */
+#if     ((478 >= GSL_INCLUDER_FIRST_CASE) && (478 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (478)))
+#define  GSL_INCLUDER_CASE       478
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 479 */
+#if     ((479 >= GSL_INCLUDER_FIRST_CASE) && (479 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (479)))
+#define  GSL_INCLUDER_CASE       479
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 480 */
+#if     ((480 >= GSL_INCLUDER_FIRST_CASE) && (480 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (480)))
+#define  GSL_INCLUDER_CASE       480
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 481 */
+#if     ((481 >= GSL_INCLUDER_FIRST_CASE) && (481 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (481)))
+#define  GSL_INCLUDER_CASE       481
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 482 */
+#if     ((482 >= GSL_INCLUDER_FIRST_CASE) && (482 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (482)))
+#define  GSL_INCLUDER_CASE       482
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 483 */
+#if     ((483 >= GSL_INCLUDER_FIRST_CASE) && (483 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (483)))
+#define  GSL_INCLUDER_CASE       483
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 484 */
+#if     ((484 >= GSL_INCLUDER_FIRST_CASE) && (484 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (484)))
+#define  GSL_INCLUDER_CASE       484
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 485 */
+#if     ((485 >= GSL_INCLUDER_FIRST_CASE) && (485 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (485)))
+#define  GSL_INCLUDER_CASE       485
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 486 */
+#if     ((486 >= GSL_INCLUDER_FIRST_CASE) && (486 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (486)))
+#define  GSL_INCLUDER_CASE       486
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 487 */
+#if     ((487 >= GSL_INCLUDER_FIRST_CASE) && (487 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (487)))
+#define  GSL_INCLUDER_CASE       487
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 488 */
+#if     ((488 >= GSL_INCLUDER_FIRST_CASE) && (488 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (488)))
+#define  GSL_INCLUDER_CASE       488
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 489 */
+#if     ((489 >= GSL_INCLUDER_FIRST_CASE) && (489 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (489)))
+#define  GSL_INCLUDER_CASE       489
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 490 */
+#if     ((490 >= GSL_INCLUDER_FIRST_CASE) && (490 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (490)))
+#define  GSL_INCLUDER_CASE       490
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 491 */
+#if     ((491 >= GSL_INCLUDER_FIRST_CASE) && (491 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (491)))
+#define  GSL_INCLUDER_CASE       491
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 492 */
+#if     ((492 >= GSL_INCLUDER_FIRST_CASE) && (492 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (492)))
+#define  GSL_INCLUDER_CASE       492
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 493 */
+#if     ((493 >= GSL_INCLUDER_FIRST_CASE) && (493 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (493)))
+#define  GSL_INCLUDER_CASE       493
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 494 */
+#if     ((494 >= GSL_INCLUDER_FIRST_CASE) && (494 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (494)))
+#define  GSL_INCLUDER_CASE       494
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 495 */
+#if     ((495 >= GSL_INCLUDER_FIRST_CASE) && (495 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (495)))
+#define  GSL_INCLUDER_CASE       495
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 496 */
+#if     ((496 >= GSL_INCLUDER_FIRST_CASE) && (496 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (496)))
+#define  GSL_INCLUDER_CASE       496
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 497 */
+#if     ((497 >= GSL_INCLUDER_FIRST_CASE) && (497 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (497)))
+#define  GSL_INCLUDER_CASE       497
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 498 */
+#if     ((498 >= GSL_INCLUDER_FIRST_CASE) && (498 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (498)))
+#define  GSL_INCLUDER_CASE       498
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 499 */
+#if     ((499 >= GSL_INCLUDER_FIRST_CASE) && (499 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (499)))
+#define  GSL_INCLUDER_CASE       499
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 500 */
+#if     ((500 >= GSL_INCLUDER_FIRST_CASE) && (500 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (500)))
+#define  GSL_INCLUDER_CASE       500
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 501 */
+#if     ((501 >= GSL_INCLUDER_FIRST_CASE) && (501 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (501)))
+#define  GSL_INCLUDER_CASE       501
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 502 */
+#if     ((502 >= GSL_INCLUDER_FIRST_CASE) && (502 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (502)))
+#define  GSL_INCLUDER_CASE       502
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 503 */
+#if     ((503 >= GSL_INCLUDER_FIRST_CASE) && (503 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (503)))
+#define  GSL_INCLUDER_CASE       503
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 504 */
+#if     ((504 >= GSL_INCLUDER_FIRST_CASE) && (504 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (504)))
+#define  GSL_INCLUDER_CASE       504
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 505 */
+#if     ((505 >= GSL_INCLUDER_FIRST_CASE) && (505 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (505)))
+#define  GSL_INCLUDER_CASE       505
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 506 */
+#if     ((506 >= GSL_INCLUDER_FIRST_CASE) && (506 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (506)))
+#define  GSL_INCLUDER_CASE       506
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 507 */
+#if     ((507 >= GSL_INCLUDER_FIRST_CASE) && (507 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (507)))
+#define  GSL_INCLUDER_CASE       507
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 508 */
+#if     ((508 >= GSL_INCLUDER_FIRST_CASE) && (508 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (508)))
+#define  GSL_INCLUDER_CASE       508
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 509 */
+#if     ((509 >= GSL_INCLUDER_FIRST_CASE) && (509 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (509)))
+#define  GSL_INCLUDER_CASE       509
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 510 */
+#if     ((510 >= GSL_INCLUDER_FIRST_CASE) && (510 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (510)))
+#define  GSL_INCLUDER_CASE       510
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 511 */
+#if     ((511 >= GSL_INCLUDER_FIRST_CASE) && (511 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (511)))
+#define  GSL_INCLUDER_CASE       511
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 512 */
+#if     ((512 >= GSL_INCLUDER_FIRST_CASE) && (512 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (512)))
+#define  GSL_INCLUDER_CASE       512
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 513 */
+#if     ((513 >= GSL_INCLUDER_FIRST_CASE) && (513 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (513)))
+#define  GSL_INCLUDER_CASE       513
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 514 */
+#if     ((514 >= GSL_INCLUDER_FIRST_CASE) && (514 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (514)))
+#define  GSL_INCLUDER_CASE       514
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 515 */
+#if     ((515 >= GSL_INCLUDER_FIRST_CASE) && (515 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (515)))
+#define  GSL_INCLUDER_CASE       515
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 516 */
+#if     ((516 >= GSL_INCLUDER_FIRST_CASE) && (516 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (516)))
+#define  GSL_INCLUDER_CASE       516
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 517 */
+#if     ((517 >= GSL_INCLUDER_FIRST_CASE) && (517 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (517)))
+#define  GSL_INCLUDER_CASE       517
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 518 */
+#if     ((518 >= GSL_INCLUDER_FIRST_CASE) && (518 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (518)))
+#define  GSL_INCLUDER_CASE       518
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 519 */
+#if     ((519 >= GSL_INCLUDER_FIRST_CASE) && (519 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (519)))
+#define  GSL_INCLUDER_CASE       519
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 520 */
+#if     ((520 >= GSL_INCLUDER_FIRST_CASE) && (520 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (520)))
+#define  GSL_INCLUDER_CASE       520
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 521 */
+#if     ((521 >= GSL_INCLUDER_FIRST_CASE) && (521 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (521)))
+#define  GSL_INCLUDER_CASE       521
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 522 */
+#if     ((522 >= GSL_INCLUDER_FIRST_CASE) && (522 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (522)))
+#define  GSL_INCLUDER_CASE       522
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 523 */
+#if     ((523 >= GSL_INCLUDER_FIRST_CASE) && (523 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (523)))
+#define  GSL_INCLUDER_CASE       523
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 524 */
+#if     ((524 >= GSL_INCLUDER_FIRST_CASE) && (524 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (524)))
+#define  GSL_INCLUDER_CASE       524
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 525 */
+#if     ((525 >= GSL_INCLUDER_FIRST_CASE) && (525 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (525)))
+#define  GSL_INCLUDER_CASE       525
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 526 */
+#if     ((526 >= GSL_INCLUDER_FIRST_CASE) && (526 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (526)))
+#define  GSL_INCLUDER_CASE       526
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 527 */
+#if     ((527 >= GSL_INCLUDER_FIRST_CASE) && (527 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (527)))
+#define  GSL_INCLUDER_CASE       527
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 528 */
+#if     ((528 >= GSL_INCLUDER_FIRST_CASE) && (528 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (528)))
+#define  GSL_INCLUDER_CASE       528
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 529 */
+#if     ((529 >= GSL_INCLUDER_FIRST_CASE) && (529 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (529)))
+#define  GSL_INCLUDER_CASE       529
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 530 */
+#if     ((530 >= GSL_INCLUDER_FIRST_CASE) && (530 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (530)))
+#define  GSL_INCLUDER_CASE       530
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 531 */
+#if     ((531 >= GSL_INCLUDER_FIRST_CASE) && (531 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (531)))
+#define  GSL_INCLUDER_CASE       531
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 532 */
+#if     ((532 >= GSL_INCLUDER_FIRST_CASE) && (532 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (532)))
+#define  GSL_INCLUDER_CASE       532
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 533 */
+#if     ((533 >= GSL_INCLUDER_FIRST_CASE) && (533 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (533)))
+#define  GSL_INCLUDER_CASE       533
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 534 */
+#if     ((534 >= GSL_INCLUDER_FIRST_CASE) && (534 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (534)))
+#define  GSL_INCLUDER_CASE       534
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 535 */
+#if     ((535 >= GSL_INCLUDER_FIRST_CASE) && (535 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (535)))
+#define  GSL_INCLUDER_CASE       535
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 536 */
+#if     ((536 >= GSL_INCLUDER_FIRST_CASE) && (536 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (536)))
+#define  GSL_INCLUDER_CASE       536
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 537 */
+#if     ((537 >= GSL_INCLUDER_FIRST_CASE) && (537 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (537)))
+#define  GSL_INCLUDER_CASE       537
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 538 */
+#if     ((538 >= GSL_INCLUDER_FIRST_CASE) && (538 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (538)))
+#define  GSL_INCLUDER_CASE       538
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 539 */
+#if     ((539 >= GSL_INCLUDER_FIRST_CASE) && (539 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (539)))
+#define  GSL_INCLUDER_CASE       539
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 540 */
+#if     ((540 >= GSL_INCLUDER_FIRST_CASE) && (540 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (540)))
+#define  GSL_INCLUDER_CASE       540
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 541 */
+#if     ((541 >= GSL_INCLUDER_FIRST_CASE) && (541 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (541)))
+#define  GSL_INCLUDER_CASE       541
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 542 */
+#if     ((542 >= GSL_INCLUDER_FIRST_CASE) && (542 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (542)))
+#define  GSL_INCLUDER_CASE       542
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 543 */
+#if     ((543 >= GSL_INCLUDER_FIRST_CASE) && (543 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (543)))
+#define  GSL_INCLUDER_CASE       543
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 544 */
+#if     ((544 >= GSL_INCLUDER_FIRST_CASE) && (544 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (544)))
+#define  GSL_INCLUDER_CASE       544
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 545 */
+#if     ((545 >= GSL_INCLUDER_FIRST_CASE) && (545 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (545)))
+#define  GSL_INCLUDER_CASE       545
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 546 */
+#if     ((546 >= GSL_INCLUDER_FIRST_CASE) && (546 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (546)))
+#define  GSL_INCLUDER_CASE       546
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 547 */
+#if     ((547 >= GSL_INCLUDER_FIRST_CASE) && (547 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (547)))
+#define  GSL_INCLUDER_CASE       547
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 548 */
+#if     ((548 >= GSL_INCLUDER_FIRST_CASE) && (548 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (548)))
+#define  GSL_INCLUDER_CASE       548
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 549 */
+#if     ((549 >= GSL_INCLUDER_FIRST_CASE) && (549 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (549)))
+#define  GSL_INCLUDER_CASE       549
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 550 */
+#if     ((550 >= GSL_INCLUDER_FIRST_CASE) && (550 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (550)))
+#define  GSL_INCLUDER_CASE       550
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 551 */
+#if     ((551 >= GSL_INCLUDER_FIRST_CASE) && (551 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (551)))
+#define  GSL_INCLUDER_CASE       551
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 552 */
+#if     ((552 >= GSL_INCLUDER_FIRST_CASE) && (552 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (552)))
+#define  GSL_INCLUDER_CASE       552
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 553 */
+#if     ((553 >= GSL_INCLUDER_FIRST_CASE) && (553 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (553)))
+#define  GSL_INCLUDER_CASE       553
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 554 */
+#if     ((554 >= GSL_INCLUDER_FIRST_CASE) && (554 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (554)))
+#define  GSL_INCLUDER_CASE       554
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 555 */
+#if     ((555 >= GSL_INCLUDER_FIRST_CASE) && (555 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (555)))
+#define  GSL_INCLUDER_CASE       555
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 556 */
+#if     ((556 >= GSL_INCLUDER_FIRST_CASE) && (556 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (556)))
+#define  GSL_INCLUDER_CASE       556
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 557 */
+#if     ((557 >= GSL_INCLUDER_FIRST_CASE) && (557 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (557)))
+#define  GSL_INCLUDER_CASE       557
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 558 */
+#if     ((558 >= GSL_INCLUDER_FIRST_CASE) && (558 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (558)))
+#define  GSL_INCLUDER_CASE       558
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 559 */
+#if     ((559 >= GSL_INCLUDER_FIRST_CASE) && (559 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (559)))
+#define  GSL_INCLUDER_CASE       559
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 560 */
+#if     ((560 >= GSL_INCLUDER_FIRST_CASE) && (560 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (560)))
+#define  GSL_INCLUDER_CASE       560
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 561 */
+#if     ((561 >= GSL_INCLUDER_FIRST_CASE) && (561 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (561)))
+#define  GSL_INCLUDER_CASE       561
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 562 */
+#if     ((562 >= GSL_INCLUDER_FIRST_CASE) && (562 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (562)))
+#define  GSL_INCLUDER_CASE       562
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 563 */
+#if     ((563 >= GSL_INCLUDER_FIRST_CASE) && (563 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (563)))
+#define  GSL_INCLUDER_CASE       563
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 564 */
+#if     ((564 >= GSL_INCLUDER_FIRST_CASE) && (564 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (564)))
+#define  GSL_INCLUDER_CASE       564
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 565 */
+#if     ((565 >= GSL_INCLUDER_FIRST_CASE) && (565 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (565)))
+#define  GSL_INCLUDER_CASE       565
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 566 */
+#if     ((566 >= GSL_INCLUDER_FIRST_CASE) && (566 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (566)))
+#define  GSL_INCLUDER_CASE       566
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 567 */
+#if     ((567 >= GSL_INCLUDER_FIRST_CASE) && (567 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (567)))
+#define  GSL_INCLUDER_CASE       567
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 568 */
+#if     ((568 >= GSL_INCLUDER_FIRST_CASE) && (568 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (568)))
+#define  GSL_INCLUDER_CASE       568
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 569 */
+#if     ((569 >= GSL_INCLUDER_FIRST_CASE) && (569 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (569)))
+#define  GSL_INCLUDER_CASE       569
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 570 */
+#if     ((570 >= GSL_INCLUDER_FIRST_CASE) && (570 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (570)))
+#define  GSL_INCLUDER_CASE       570
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 571 */
+#if     ((571 >= GSL_INCLUDER_FIRST_CASE) && (571 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (571)))
+#define  GSL_INCLUDER_CASE       571
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 572 */
+#if     ((572 >= GSL_INCLUDER_FIRST_CASE) && (572 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (572)))
+#define  GSL_INCLUDER_CASE       572
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 573 */
+#if     ((573 >= GSL_INCLUDER_FIRST_CASE) && (573 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (573)))
+#define  GSL_INCLUDER_CASE       573
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 574 */
+#if     ((574 >= GSL_INCLUDER_FIRST_CASE) && (574 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (574)))
+#define  GSL_INCLUDER_CASE       574
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 575 */
+#if     ((575 >= GSL_INCLUDER_FIRST_CASE) && (575 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (575)))
+#define  GSL_INCLUDER_CASE       575
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 576 */
+#if     ((576 >= GSL_INCLUDER_FIRST_CASE) && (576 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (576)))
+#define  GSL_INCLUDER_CASE       576
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 577 */
+#if     ((577 >= GSL_INCLUDER_FIRST_CASE) && (577 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (577)))
+#define  GSL_INCLUDER_CASE       577
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 578 */
+#if     ((578 >= GSL_INCLUDER_FIRST_CASE) && (578 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (578)))
+#define  GSL_INCLUDER_CASE       578
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 579 */
+#if     ((579 >= GSL_INCLUDER_FIRST_CASE) && (579 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (579)))
+#define  GSL_INCLUDER_CASE       579
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 580 */
+#if     ((580 >= GSL_INCLUDER_FIRST_CASE) && (580 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (580)))
+#define  GSL_INCLUDER_CASE       580
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 581 */
+#if     ((581 >= GSL_INCLUDER_FIRST_CASE) && (581 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (581)))
+#define  GSL_INCLUDER_CASE       581
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 582 */
+#if     ((582 >= GSL_INCLUDER_FIRST_CASE) && (582 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (582)))
+#define  GSL_INCLUDER_CASE       582
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 583 */
+#if     ((583 >= GSL_INCLUDER_FIRST_CASE) && (583 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (583)))
+#define  GSL_INCLUDER_CASE       583
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 584 */
+#if     ((584 >= GSL_INCLUDER_FIRST_CASE) && (584 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (584)))
+#define  GSL_INCLUDER_CASE       584
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 585 */
+#if     ((585 >= GSL_INCLUDER_FIRST_CASE) && (585 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (585)))
+#define  GSL_INCLUDER_CASE       585
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 586 */
+#if     ((586 >= GSL_INCLUDER_FIRST_CASE) && (586 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (586)))
+#define  GSL_INCLUDER_CASE       586
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 587 */
+#if     ((587 >= GSL_INCLUDER_FIRST_CASE) && (587 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (587)))
+#define  GSL_INCLUDER_CASE       587
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 588 */
+#if     ((588 >= GSL_INCLUDER_FIRST_CASE) && (588 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (588)))
+#define  GSL_INCLUDER_CASE       588
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 589 */
+#if     ((589 >= GSL_INCLUDER_FIRST_CASE) && (589 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (589)))
+#define  GSL_INCLUDER_CASE       589
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 590 */
+#if     ((590 >= GSL_INCLUDER_FIRST_CASE) && (590 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (590)))
+#define  GSL_INCLUDER_CASE       590
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 591 */
+#if     ((591 >= GSL_INCLUDER_FIRST_CASE) && (591 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (591)))
+#define  GSL_INCLUDER_CASE       591
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 592 */
+#if     ((592 >= GSL_INCLUDER_FIRST_CASE) && (592 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (592)))
+#define  GSL_INCLUDER_CASE       592
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 593 */
+#if     ((593 >= GSL_INCLUDER_FIRST_CASE) && (593 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (593)))
+#define  GSL_INCLUDER_CASE       593
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 594 */
+#if     ((594 >= GSL_INCLUDER_FIRST_CASE) && (594 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (594)))
+#define  GSL_INCLUDER_CASE       594
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 595 */
+#if     ((595 >= GSL_INCLUDER_FIRST_CASE) && (595 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (595)))
+#define  GSL_INCLUDER_CASE       595
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 596 */
+#if     ((596 >= GSL_INCLUDER_FIRST_CASE) && (596 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (596)))
+#define  GSL_INCLUDER_CASE       596
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 597 */
+#if     ((597 >= GSL_INCLUDER_FIRST_CASE) && (597 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (597)))
+#define  GSL_INCLUDER_CASE       597
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 598 */
+#if     ((598 >= GSL_INCLUDER_FIRST_CASE) && (598 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (598)))
+#define  GSL_INCLUDER_CASE       598
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 599 */
+#if     ((599 >= GSL_INCLUDER_FIRST_CASE) && (599 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (599)))
+#define  GSL_INCLUDER_CASE       599
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 600 */
+#if     ((600 >= GSL_INCLUDER_FIRST_CASE) && (600 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (600)))
+#define  GSL_INCLUDER_CASE       600
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 601 */
+#if     ((601 >= GSL_INCLUDER_FIRST_CASE) && (601 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (601)))
+#define  GSL_INCLUDER_CASE       601
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 602 */
+#if     ((602 >= GSL_INCLUDER_FIRST_CASE) && (602 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (602)))
+#define  GSL_INCLUDER_CASE       602
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 603 */
+#if     ((603 >= GSL_INCLUDER_FIRST_CASE) && (603 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (603)))
+#define  GSL_INCLUDER_CASE       603
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 604 */
+#if     ((604 >= GSL_INCLUDER_FIRST_CASE) && (604 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (604)))
+#define  GSL_INCLUDER_CASE       604
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 605 */
+#if     ((605 >= GSL_INCLUDER_FIRST_CASE) && (605 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (605)))
+#define  GSL_INCLUDER_CASE       605
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 606 */
+#if     ((606 >= GSL_INCLUDER_FIRST_CASE) && (606 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (606)))
+#define  GSL_INCLUDER_CASE       606
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 607 */
+#if     ((607 >= GSL_INCLUDER_FIRST_CASE) && (607 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (607)))
+#define  GSL_INCLUDER_CASE       607
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 608 */
+#if     ((608 >= GSL_INCLUDER_FIRST_CASE) && (608 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (608)))
+#define  GSL_INCLUDER_CASE       608
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 609 */
+#if     ((609 >= GSL_INCLUDER_FIRST_CASE) && (609 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (609)))
+#define  GSL_INCLUDER_CASE       609
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 610 */
+#if     ((610 >= GSL_INCLUDER_FIRST_CASE) && (610 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (610)))
+#define  GSL_INCLUDER_CASE       610
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 611 */
+#if     ((611 >= GSL_INCLUDER_FIRST_CASE) && (611 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (611)))
+#define  GSL_INCLUDER_CASE       611
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 612 */
+#if     ((612 >= GSL_INCLUDER_FIRST_CASE) && (612 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (612)))
+#define  GSL_INCLUDER_CASE       612
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 613 */
+#if     ((613 >= GSL_INCLUDER_FIRST_CASE) && (613 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (613)))
+#define  GSL_INCLUDER_CASE       613
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 614 */
+#if     ((614 >= GSL_INCLUDER_FIRST_CASE) && (614 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (614)))
+#define  GSL_INCLUDER_CASE       614
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 615 */
+#if     ((615 >= GSL_INCLUDER_FIRST_CASE) && (615 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (615)))
+#define  GSL_INCLUDER_CASE       615
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 616 */
+#if     ((616 >= GSL_INCLUDER_FIRST_CASE) && (616 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (616)))
+#define  GSL_INCLUDER_CASE       616
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 617 */
+#if     ((617 >= GSL_INCLUDER_FIRST_CASE) && (617 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (617)))
+#define  GSL_INCLUDER_CASE       617
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 618 */
+#if     ((618 >= GSL_INCLUDER_FIRST_CASE) && (618 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (618)))
+#define  GSL_INCLUDER_CASE       618
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 619 */
+#if     ((619 >= GSL_INCLUDER_FIRST_CASE) && (619 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (619)))
+#define  GSL_INCLUDER_CASE       619
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 620 */
+#if     ((620 >= GSL_INCLUDER_FIRST_CASE) && (620 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (620)))
+#define  GSL_INCLUDER_CASE       620
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 621 */
+#if     ((621 >= GSL_INCLUDER_FIRST_CASE) && (621 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (621)))
+#define  GSL_INCLUDER_CASE       621
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 622 */
+#if     ((622 >= GSL_INCLUDER_FIRST_CASE) && (622 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (622)))
+#define  GSL_INCLUDER_CASE       622
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 623 */
+#if     ((623 >= GSL_INCLUDER_FIRST_CASE) && (623 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (623)))
+#define  GSL_INCLUDER_CASE       623
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 624 */
+#if     ((624 >= GSL_INCLUDER_FIRST_CASE) && (624 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (624)))
+#define  GSL_INCLUDER_CASE       624
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 625 */
+#if     ((625 >= GSL_INCLUDER_FIRST_CASE) && (625 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (625)))
+#define  GSL_INCLUDER_CASE       625
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 626 */
+#if     ((626 >= GSL_INCLUDER_FIRST_CASE) && (626 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (626)))
+#define  GSL_INCLUDER_CASE       626
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 627 */
+#if     ((627 >= GSL_INCLUDER_FIRST_CASE) && (627 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (627)))
+#define  GSL_INCLUDER_CASE       627
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 628 */
+#if     ((628 >= GSL_INCLUDER_FIRST_CASE) && (628 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (628)))
+#define  GSL_INCLUDER_CASE       628
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 629 */
+#if     ((629 >= GSL_INCLUDER_FIRST_CASE) && (629 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (629)))
+#define  GSL_INCLUDER_CASE       629
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 630 */
+#if     ((630 >= GSL_INCLUDER_FIRST_CASE) && (630 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (630)))
+#define  GSL_INCLUDER_CASE       630
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 631 */
+#if     ((631 >= GSL_INCLUDER_FIRST_CASE) && (631 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (631)))
+#define  GSL_INCLUDER_CASE       631
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 632 */
+#if     ((632 >= GSL_INCLUDER_FIRST_CASE) && (632 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (632)))
+#define  GSL_INCLUDER_CASE       632
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 633 */
+#if     ((633 >= GSL_INCLUDER_FIRST_CASE) && (633 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (633)))
+#define  GSL_INCLUDER_CASE       633
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 634 */
+#if     ((634 >= GSL_INCLUDER_FIRST_CASE) && (634 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (634)))
+#define  GSL_INCLUDER_CASE       634
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 635 */
+#if     ((635 >= GSL_INCLUDER_FIRST_CASE) && (635 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (635)))
+#define  GSL_INCLUDER_CASE       635
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 636 */
+#if     ((636 >= GSL_INCLUDER_FIRST_CASE) && (636 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (636)))
+#define  GSL_INCLUDER_CASE       636
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 637 */
+#if     ((637 >= GSL_INCLUDER_FIRST_CASE) && (637 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (637)))
+#define  GSL_INCLUDER_CASE       637
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 638 */
+#if     ((638 >= GSL_INCLUDER_FIRST_CASE) && (638 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (638)))
+#define  GSL_INCLUDER_CASE       638
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 639 */
+#if     ((639 >= GSL_INCLUDER_FIRST_CASE) && (639 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (639)))
+#define  GSL_INCLUDER_CASE       639
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 640 */
+#if     ((640 >= GSL_INCLUDER_FIRST_CASE) && (640 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (640)))
+#define  GSL_INCLUDER_CASE       640
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 641 */
+#if     ((641 >= GSL_INCLUDER_FIRST_CASE) && (641 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (641)))
+#define  GSL_INCLUDER_CASE       641
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 642 */
+#if     ((642 >= GSL_INCLUDER_FIRST_CASE) && (642 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (642)))
+#define  GSL_INCLUDER_CASE       642
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 643 */
+#if     ((643 >= GSL_INCLUDER_FIRST_CASE) && (643 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (643)))
+#define  GSL_INCLUDER_CASE       643
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 644 */
+#if     ((644 >= GSL_INCLUDER_FIRST_CASE) && (644 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (644)))
+#define  GSL_INCLUDER_CASE       644
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 645 */
+#if     ((645 >= GSL_INCLUDER_FIRST_CASE) && (645 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (645)))
+#define  GSL_INCLUDER_CASE       645
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 646 */
+#if     ((646 >= GSL_INCLUDER_FIRST_CASE) && (646 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (646)))
+#define  GSL_INCLUDER_CASE       646
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 647 */
+#if     ((647 >= GSL_INCLUDER_FIRST_CASE) && (647 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (647)))
+#define  GSL_INCLUDER_CASE       647
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 648 */
+#if     ((648 >= GSL_INCLUDER_FIRST_CASE) && (648 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (648)))
+#define  GSL_INCLUDER_CASE       648
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 649 */
+#if     ((649 >= GSL_INCLUDER_FIRST_CASE) && (649 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (649)))
+#define  GSL_INCLUDER_CASE       649
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 650 */
+#if     ((650 >= GSL_INCLUDER_FIRST_CASE) && (650 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (650)))
+#define  GSL_INCLUDER_CASE       650
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 651 */
+#if     ((651 >= GSL_INCLUDER_FIRST_CASE) && (651 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (651)))
+#define  GSL_INCLUDER_CASE       651
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 652 */
+#if     ((652 >= GSL_INCLUDER_FIRST_CASE) && (652 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (652)))
+#define  GSL_INCLUDER_CASE       652
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 653 */
+#if     ((653 >= GSL_INCLUDER_FIRST_CASE) && (653 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (653)))
+#define  GSL_INCLUDER_CASE       653
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 654 */
+#if     ((654 >= GSL_INCLUDER_FIRST_CASE) && (654 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (654)))
+#define  GSL_INCLUDER_CASE       654
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 655 */
+#if     ((655 >= GSL_INCLUDER_FIRST_CASE) && (655 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (655)))
+#define  GSL_INCLUDER_CASE       655
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 656 */
+#if     ((656 >= GSL_INCLUDER_FIRST_CASE) && (656 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (656)))
+#define  GSL_INCLUDER_CASE       656
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 657 */
+#if     ((657 >= GSL_INCLUDER_FIRST_CASE) && (657 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (657)))
+#define  GSL_INCLUDER_CASE       657
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 658 */
+#if     ((658 >= GSL_INCLUDER_FIRST_CASE) && (658 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (658)))
+#define  GSL_INCLUDER_CASE       658
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 659 */
+#if     ((659 >= GSL_INCLUDER_FIRST_CASE) && (659 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (659)))
+#define  GSL_INCLUDER_CASE       659
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 660 */
+#if     ((660 >= GSL_INCLUDER_FIRST_CASE) && (660 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (660)))
+#define  GSL_INCLUDER_CASE       660
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 661 */
+#if     ((661 >= GSL_INCLUDER_FIRST_CASE) && (661 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (661)))
+#define  GSL_INCLUDER_CASE       661
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 662 */
+#if     ((662 >= GSL_INCLUDER_FIRST_CASE) && (662 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (662)))
+#define  GSL_INCLUDER_CASE       662
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 663 */
+#if     ((663 >= GSL_INCLUDER_FIRST_CASE) && (663 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (663)))
+#define  GSL_INCLUDER_CASE       663
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 664 */
+#if     ((664 >= GSL_INCLUDER_FIRST_CASE) && (664 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (664)))
+#define  GSL_INCLUDER_CASE       664
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 665 */
+#if     ((665 >= GSL_INCLUDER_FIRST_CASE) && (665 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (665)))
+#define  GSL_INCLUDER_CASE       665
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 666 */
+#if     ((666 >= GSL_INCLUDER_FIRST_CASE) && (666 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (666)))
+#define  GSL_INCLUDER_CASE       666
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 667 */
+#if     ((667 >= GSL_INCLUDER_FIRST_CASE) && (667 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (667)))
+#define  GSL_INCLUDER_CASE       667
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 668 */
+#if     ((668 >= GSL_INCLUDER_FIRST_CASE) && (668 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (668)))
+#define  GSL_INCLUDER_CASE       668
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 669 */
+#if     ((669 >= GSL_INCLUDER_FIRST_CASE) && (669 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (669)))
+#define  GSL_INCLUDER_CASE       669
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 670 */
+#if     ((670 >= GSL_INCLUDER_FIRST_CASE) && (670 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (670)))
+#define  GSL_INCLUDER_CASE       670
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 671 */
+#if     ((671 >= GSL_INCLUDER_FIRST_CASE) && (671 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (671)))
+#define  GSL_INCLUDER_CASE       671
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 672 */
+#if     ((672 >= GSL_INCLUDER_FIRST_CASE) && (672 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (672)))
+#define  GSL_INCLUDER_CASE       672
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 673 */
+#if     ((673 >= GSL_INCLUDER_FIRST_CASE) && (673 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (673)))
+#define  GSL_INCLUDER_CASE       673
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 674 */
+#if     ((674 >= GSL_INCLUDER_FIRST_CASE) && (674 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (674)))
+#define  GSL_INCLUDER_CASE       674
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 675 */
+#if     ((675 >= GSL_INCLUDER_FIRST_CASE) && (675 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (675)))
+#define  GSL_INCLUDER_CASE       675
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 676 */
+#if     ((676 >= GSL_INCLUDER_FIRST_CASE) && (676 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (676)))
+#define  GSL_INCLUDER_CASE       676
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 677 */
+#if     ((677 >= GSL_INCLUDER_FIRST_CASE) && (677 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (677)))
+#define  GSL_INCLUDER_CASE       677
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 678 */
+#if     ((678 >= GSL_INCLUDER_FIRST_CASE) && (678 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (678)))
+#define  GSL_INCLUDER_CASE       678
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 679 */
+#if     ((679 >= GSL_INCLUDER_FIRST_CASE) && (679 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (679)))
+#define  GSL_INCLUDER_CASE       679
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 680 */
+#if     ((680 >= GSL_INCLUDER_FIRST_CASE) && (680 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (680)))
+#define  GSL_INCLUDER_CASE       680
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 681 */
+#if     ((681 >= GSL_INCLUDER_FIRST_CASE) && (681 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (681)))
+#define  GSL_INCLUDER_CASE       681
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 682 */
+#if     ((682 >= GSL_INCLUDER_FIRST_CASE) && (682 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (682)))
+#define  GSL_INCLUDER_CASE       682
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 683 */
+#if     ((683 >= GSL_INCLUDER_FIRST_CASE) && (683 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (683)))
+#define  GSL_INCLUDER_CASE       683
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 684 */
+#if     ((684 >= GSL_INCLUDER_FIRST_CASE) && (684 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (684)))
+#define  GSL_INCLUDER_CASE       684
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 685 */
+#if     ((685 >= GSL_INCLUDER_FIRST_CASE) && (685 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (685)))
+#define  GSL_INCLUDER_CASE       685
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 686 */
+#if     ((686 >= GSL_INCLUDER_FIRST_CASE) && (686 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (686)))
+#define  GSL_INCLUDER_CASE       686
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 687 */
+#if     ((687 >= GSL_INCLUDER_FIRST_CASE) && (687 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (687)))
+#define  GSL_INCLUDER_CASE       687
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 688 */
+#if     ((688 >= GSL_INCLUDER_FIRST_CASE) && (688 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (688)))
+#define  GSL_INCLUDER_CASE       688
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 689 */
+#if     ((689 >= GSL_INCLUDER_FIRST_CASE) && (689 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (689)))
+#define  GSL_INCLUDER_CASE       689
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 690 */
+#if     ((690 >= GSL_INCLUDER_FIRST_CASE) && (690 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (690)))
+#define  GSL_INCLUDER_CASE       690
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 691 */
+#if     ((691 >= GSL_INCLUDER_FIRST_CASE) && (691 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (691)))
+#define  GSL_INCLUDER_CASE       691
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 692 */
+#if     ((692 >= GSL_INCLUDER_FIRST_CASE) && (692 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (692)))
+#define  GSL_INCLUDER_CASE       692
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 693 */
+#if     ((693 >= GSL_INCLUDER_FIRST_CASE) && (693 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (693)))
+#define  GSL_INCLUDER_CASE       693
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 694 */
+#if     ((694 >= GSL_INCLUDER_FIRST_CASE) && (694 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (694)))
+#define  GSL_INCLUDER_CASE       694
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 695 */
+#if     ((695 >= GSL_INCLUDER_FIRST_CASE) && (695 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (695)))
+#define  GSL_INCLUDER_CASE       695
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 696 */
+#if     ((696 >= GSL_INCLUDER_FIRST_CASE) && (696 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (696)))
+#define  GSL_INCLUDER_CASE       696
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 697 */
+#if     ((697 >= GSL_INCLUDER_FIRST_CASE) && (697 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (697)))
+#define  GSL_INCLUDER_CASE       697
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 698 */
+#if     ((698 >= GSL_INCLUDER_FIRST_CASE) && (698 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (698)))
+#define  GSL_INCLUDER_CASE       698
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 699 */
+#if     ((699 >= GSL_INCLUDER_FIRST_CASE) && (699 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (699)))
+#define  GSL_INCLUDER_CASE       699
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 700 */
+#if     ((700 >= GSL_INCLUDER_FIRST_CASE) && (700 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (700)))
+#define  GSL_INCLUDER_CASE       700
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 701 */
+#if     ((701 >= GSL_INCLUDER_FIRST_CASE) && (701 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (701)))
+#define  GSL_INCLUDER_CASE       701
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 702 */
+#if     ((702 >= GSL_INCLUDER_FIRST_CASE) && (702 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (702)))
+#define  GSL_INCLUDER_CASE       702
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 703 */
+#if     ((703 >= GSL_INCLUDER_FIRST_CASE) && (703 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (703)))
+#define  GSL_INCLUDER_CASE       703
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 704 */
+#if     ((704 >= GSL_INCLUDER_FIRST_CASE) && (704 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (704)))
+#define  GSL_INCLUDER_CASE       704
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 705 */
+#if     ((705 >= GSL_INCLUDER_FIRST_CASE) && (705 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (705)))
+#define  GSL_INCLUDER_CASE       705
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 706 */
+#if     ((706 >= GSL_INCLUDER_FIRST_CASE) && (706 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (706)))
+#define  GSL_INCLUDER_CASE       706
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 707 */
+#if     ((707 >= GSL_INCLUDER_FIRST_CASE) && (707 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (707)))
+#define  GSL_INCLUDER_CASE       707
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 708 */
+#if     ((708 >= GSL_INCLUDER_FIRST_CASE) && (708 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (708)))
+#define  GSL_INCLUDER_CASE       708
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 709 */
+#if     ((709 >= GSL_INCLUDER_FIRST_CASE) && (709 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (709)))
+#define  GSL_INCLUDER_CASE       709
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 710 */
+#if     ((710 >= GSL_INCLUDER_FIRST_CASE) && (710 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (710)))
+#define  GSL_INCLUDER_CASE       710
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 711 */
+#if     ((711 >= GSL_INCLUDER_FIRST_CASE) && (711 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (711)))
+#define  GSL_INCLUDER_CASE       711
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 712 */
+#if     ((712 >= GSL_INCLUDER_FIRST_CASE) && (712 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (712)))
+#define  GSL_INCLUDER_CASE       712
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 713 */
+#if     ((713 >= GSL_INCLUDER_FIRST_CASE) && (713 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (713)))
+#define  GSL_INCLUDER_CASE       713
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 714 */
+#if     ((714 >= GSL_INCLUDER_FIRST_CASE) && (714 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (714)))
+#define  GSL_INCLUDER_CASE       714
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 715 */
+#if     ((715 >= GSL_INCLUDER_FIRST_CASE) && (715 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (715)))
+#define  GSL_INCLUDER_CASE       715
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 716 */
+#if     ((716 >= GSL_INCLUDER_FIRST_CASE) && (716 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (716)))
+#define  GSL_INCLUDER_CASE       716
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 717 */
+#if     ((717 >= GSL_INCLUDER_FIRST_CASE) && (717 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (717)))
+#define  GSL_INCLUDER_CASE       717
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 718 */
+#if     ((718 >= GSL_INCLUDER_FIRST_CASE) && (718 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (718)))
+#define  GSL_INCLUDER_CASE       718
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 719 */
+#if     ((719 >= GSL_INCLUDER_FIRST_CASE) && (719 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (719)))
+#define  GSL_INCLUDER_CASE       719
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 720 */
+#if     ((720 >= GSL_INCLUDER_FIRST_CASE) && (720 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (720)))
+#define  GSL_INCLUDER_CASE       720
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 721 */
+#if     ((721 >= GSL_INCLUDER_FIRST_CASE) && (721 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (721)))
+#define  GSL_INCLUDER_CASE       721
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 722 */
+#if     ((722 >= GSL_INCLUDER_FIRST_CASE) && (722 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (722)))
+#define  GSL_INCLUDER_CASE       722
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 723 */
+#if     ((723 >= GSL_INCLUDER_FIRST_CASE) && (723 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (723)))
+#define  GSL_INCLUDER_CASE       723
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 724 */
+#if     ((724 >= GSL_INCLUDER_FIRST_CASE) && (724 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (724)))
+#define  GSL_INCLUDER_CASE       724
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 725 */
+#if     ((725 >= GSL_INCLUDER_FIRST_CASE) && (725 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (725)))
+#define  GSL_INCLUDER_CASE       725
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 726 */
+#if     ((726 >= GSL_INCLUDER_FIRST_CASE) && (726 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (726)))
+#define  GSL_INCLUDER_CASE       726
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 727 */
+#if     ((727 >= GSL_INCLUDER_FIRST_CASE) && (727 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (727)))
+#define  GSL_INCLUDER_CASE       727
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 728 */
+#if     ((728 >= GSL_INCLUDER_FIRST_CASE) && (728 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (728)))
+#define  GSL_INCLUDER_CASE       728
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 729 */
+#if     ((729 >= GSL_INCLUDER_FIRST_CASE) && (729 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (729)))
+#define  GSL_INCLUDER_CASE       729
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 730 */
+#if     ((730 >= GSL_INCLUDER_FIRST_CASE) && (730 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (730)))
+#define  GSL_INCLUDER_CASE       730
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 731 */
+#if     ((731 >= GSL_INCLUDER_FIRST_CASE) && (731 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (731)))
+#define  GSL_INCLUDER_CASE       731
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 732 */
+#if     ((732 >= GSL_INCLUDER_FIRST_CASE) && (732 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (732)))
+#define  GSL_INCLUDER_CASE       732
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 733 */
+#if     ((733 >= GSL_INCLUDER_FIRST_CASE) && (733 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (733)))
+#define  GSL_INCLUDER_CASE       733
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 734 */
+#if     ((734 >= GSL_INCLUDER_FIRST_CASE) && (734 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (734)))
+#define  GSL_INCLUDER_CASE       734
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 735 */
+#if     ((735 >= GSL_INCLUDER_FIRST_CASE) && (735 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (735)))
+#define  GSL_INCLUDER_CASE       735
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 736 */
+#if     ((736 >= GSL_INCLUDER_FIRST_CASE) && (736 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (736)))
+#define  GSL_INCLUDER_CASE       736
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 737 */
+#if     ((737 >= GSL_INCLUDER_FIRST_CASE) && (737 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (737)))
+#define  GSL_INCLUDER_CASE       737
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 738 */
+#if     ((738 >= GSL_INCLUDER_FIRST_CASE) && (738 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (738)))
+#define  GSL_INCLUDER_CASE       738
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 739 */
+#if     ((739 >= GSL_INCLUDER_FIRST_CASE) && (739 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (739)))
+#define  GSL_INCLUDER_CASE       739
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 740 */
+#if     ((740 >= GSL_INCLUDER_FIRST_CASE) && (740 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (740)))
+#define  GSL_INCLUDER_CASE       740
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 741 */
+#if     ((741 >= GSL_INCLUDER_FIRST_CASE) && (741 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (741)))
+#define  GSL_INCLUDER_CASE       741
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 742 */
+#if     ((742 >= GSL_INCLUDER_FIRST_CASE) && (742 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (742)))
+#define  GSL_INCLUDER_CASE       742
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 743 */
+#if     ((743 >= GSL_INCLUDER_FIRST_CASE) && (743 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (743)))
+#define  GSL_INCLUDER_CASE       743
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 744 */
+#if     ((744 >= GSL_INCLUDER_FIRST_CASE) && (744 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (744)))
+#define  GSL_INCLUDER_CASE       744
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 745 */
+#if     ((745 >= GSL_INCLUDER_FIRST_CASE) && (745 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (745)))
+#define  GSL_INCLUDER_CASE       745
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 746 */
+#if     ((746 >= GSL_INCLUDER_FIRST_CASE) && (746 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (746)))
+#define  GSL_INCLUDER_CASE       746
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 747 */
+#if     ((747 >= GSL_INCLUDER_FIRST_CASE) && (747 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (747)))
+#define  GSL_INCLUDER_CASE       747
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 748 */
+#if     ((748 >= GSL_INCLUDER_FIRST_CASE) && (748 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (748)))
+#define  GSL_INCLUDER_CASE       748
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 749 */
+#if     ((749 >= GSL_INCLUDER_FIRST_CASE) && (749 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (749)))
+#define  GSL_INCLUDER_CASE       749
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 750 */
+#if     ((750 >= GSL_INCLUDER_FIRST_CASE) && (750 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (750)))
+#define  GSL_INCLUDER_CASE       750
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 751 */
+#if     ((751 >= GSL_INCLUDER_FIRST_CASE) && (751 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (751)))
+#define  GSL_INCLUDER_CASE       751
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 752 */
+#if     ((752 >= GSL_INCLUDER_FIRST_CASE) && (752 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (752)))
+#define  GSL_INCLUDER_CASE       752
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 753 */
+#if     ((753 >= GSL_INCLUDER_FIRST_CASE) && (753 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (753)))
+#define  GSL_INCLUDER_CASE       753
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 754 */
+#if     ((754 >= GSL_INCLUDER_FIRST_CASE) && (754 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (754)))
+#define  GSL_INCLUDER_CASE       754
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 755 */
+#if     ((755 >= GSL_INCLUDER_FIRST_CASE) && (755 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (755)))
+#define  GSL_INCLUDER_CASE       755
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 756 */
+#if     ((756 >= GSL_INCLUDER_FIRST_CASE) && (756 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (756)))
+#define  GSL_INCLUDER_CASE       756
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 757 */
+#if     ((757 >= GSL_INCLUDER_FIRST_CASE) && (757 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (757)))
+#define  GSL_INCLUDER_CASE       757
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 758 */
+#if     ((758 >= GSL_INCLUDER_FIRST_CASE) && (758 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (758)))
+#define  GSL_INCLUDER_CASE       758
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 759 */
+#if     ((759 >= GSL_INCLUDER_FIRST_CASE) && (759 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (759)))
+#define  GSL_INCLUDER_CASE       759
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 760 */
+#if     ((760 >= GSL_INCLUDER_FIRST_CASE) && (760 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (760)))
+#define  GSL_INCLUDER_CASE       760
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 761 */
+#if     ((761 >= GSL_INCLUDER_FIRST_CASE) && (761 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (761)))
+#define  GSL_INCLUDER_CASE       761
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 762 */
+#if     ((762 >= GSL_INCLUDER_FIRST_CASE) && (762 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (762)))
+#define  GSL_INCLUDER_CASE       762
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 763 */
+#if     ((763 >= GSL_INCLUDER_FIRST_CASE) && (763 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (763)))
+#define  GSL_INCLUDER_CASE       763
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 764 */
+#if     ((764 >= GSL_INCLUDER_FIRST_CASE) && (764 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (764)))
+#define  GSL_INCLUDER_CASE       764
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 765 */
+#if     ((765 >= GSL_INCLUDER_FIRST_CASE) && (765 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (765)))
+#define  GSL_INCLUDER_CASE       765
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 766 */
+#if     ((766 >= GSL_INCLUDER_FIRST_CASE) && (766 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (766)))
+#define  GSL_INCLUDER_CASE       766
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 767 */
+#if     ((767 >= GSL_INCLUDER_FIRST_CASE) && (767 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (767)))
+#define  GSL_INCLUDER_CASE       767
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 768 */
+#if     ((768 >= GSL_INCLUDER_FIRST_CASE) && (768 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (768)))
+#define  GSL_INCLUDER_CASE       768
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 769 */
+#if     ((769 >= GSL_INCLUDER_FIRST_CASE) && (769 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (769)))
+#define  GSL_INCLUDER_CASE       769
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 770 */
+#if     ((770 >= GSL_INCLUDER_FIRST_CASE) && (770 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (770)))
+#define  GSL_INCLUDER_CASE       770
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 771 */
+#if     ((771 >= GSL_INCLUDER_FIRST_CASE) && (771 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (771)))
+#define  GSL_INCLUDER_CASE       771
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 772 */
+#if     ((772 >= GSL_INCLUDER_FIRST_CASE) && (772 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (772)))
+#define  GSL_INCLUDER_CASE       772
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 773 */
+#if     ((773 >= GSL_INCLUDER_FIRST_CASE) && (773 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (773)))
+#define  GSL_INCLUDER_CASE       773
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 774 */
+#if     ((774 >= GSL_INCLUDER_FIRST_CASE) && (774 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (774)))
+#define  GSL_INCLUDER_CASE       774
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 775 */
+#if     ((775 >= GSL_INCLUDER_FIRST_CASE) && (775 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (775)))
+#define  GSL_INCLUDER_CASE       775
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 776 */
+#if     ((776 >= GSL_INCLUDER_FIRST_CASE) && (776 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (776)))
+#define  GSL_INCLUDER_CASE       776
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 777 */
+#if     ((777 >= GSL_INCLUDER_FIRST_CASE) && (777 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (777)))
+#define  GSL_INCLUDER_CASE       777
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 778 */
+#if     ((778 >= GSL_INCLUDER_FIRST_CASE) && (778 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (778)))
+#define  GSL_INCLUDER_CASE       778
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 779 */
+#if     ((779 >= GSL_INCLUDER_FIRST_CASE) && (779 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (779)))
+#define  GSL_INCLUDER_CASE       779
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 780 */
+#if     ((780 >= GSL_INCLUDER_FIRST_CASE) && (780 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (780)))
+#define  GSL_INCLUDER_CASE       780
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 781 */
+#if     ((781 >= GSL_INCLUDER_FIRST_CASE) && (781 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (781)))
+#define  GSL_INCLUDER_CASE       781
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 782 */
+#if     ((782 >= GSL_INCLUDER_FIRST_CASE) && (782 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (782)))
+#define  GSL_INCLUDER_CASE       782
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 783 */
+#if     ((783 >= GSL_INCLUDER_FIRST_CASE) && (783 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (783)))
+#define  GSL_INCLUDER_CASE       783
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 784 */
+#if     ((784 >= GSL_INCLUDER_FIRST_CASE) && (784 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (784)))
+#define  GSL_INCLUDER_CASE       784
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 785 */
+#if     ((785 >= GSL_INCLUDER_FIRST_CASE) && (785 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (785)))
+#define  GSL_INCLUDER_CASE       785
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 786 */
+#if     ((786 >= GSL_INCLUDER_FIRST_CASE) && (786 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (786)))
+#define  GSL_INCLUDER_CASE       786
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 787 */
+#if     ((787 >= GSL_INCLUDER_FIRST_CASE) && (787 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (787)))
+#define  GSL_INCLUDER_CASE       787
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 788 */
+#if     ((788 >= GSL_INCLUDER_FIRST_CASE) && (788 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (788)))
+#define  GSL_INCLUDER_CASE       788
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 789 */
+#if     ((789 >= GSL_INCLUDER_FIRST_CASE) && (789 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (789)))
+#define  GSL_INCLUDER_CASE       789
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 790 */
+#if     ((790 >= GSL_INCLUDER_FIRST_CASE) && (790 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (790)))
+#define  GSL_INCLUDER_CASE       790
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 791 */
+#if     ((791 >= GSL_INCLUDER_FIRST_CASE) && (791 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (791)))
+#define  GSL_INCLUDER_CASE       791
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 792 */
+#if     ((792 >= GSL_INCLUDER_FIRST_CASE) && (792 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (792)))
+#define  GSL_INCLUDER_CASE       792
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 793 */
+#if     ((793 >= GSL_INCLUDER_FIRST_CASE) && (793 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (793)))
+#define  GSL_INCLUDER_CASE       793
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 794 */
+#if     ((794 >= GSL_INCLUDER_FIRST_CASE) && (794 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (794)))
+#define  GSL_INCLUDER_CASE       794
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 795 */
+#if     ((795 >= GSL_INCLUDER_FIRST_CASE) && (795 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (795)))
+#define  GSL_INCLUDER_CASE       795
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 796 */
+#if     ((796 >= GSL_INCLUDER_FIRST_CASE) && (796 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (796)))
+#define  GSL_INCLUDER_CASE       796
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 797 */
+#if     ((797 >= GSL_INCLUDER_FIRST_CASE) && (797 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (797)))
+#define  GSL_INCLUDER_CASE       797
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 798 */
+#if     ((798 >= GSL_INCLUDER_FIRST_CASE) && (798 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (798)))
+#define  GSL_INCLUDER_CASE       798
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 799 */
+#if     ((799 >= GSL_INCLUDER_FIRST_CASE) && (799 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (799)))
+#define  GSL_INCLUDER_CASE       799
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 800 */
+#if     ((800 >= GSL_INCLUDER_FIRST_CASE) && (800 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (800)))
+#define  GSL_INCLUDER_CASE       800
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 801 */
+#if     ((801 >= GSL_INCLUDER_FIRST_CASE) && (801 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (801)))
+#define  GSL_INCLUDER_CASE       801
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 802 */
+#if     ((802 >= GSL_INCLUDER_FIRST_CASE) && (802 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (802)))
+#define  GSL_INCLUDER_CASE       802
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 803 */
+#if     ((803 >= GSL_INCLUDER_FIRST_CASE) && (803 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (803)))
+#define  GSL_INCLUDER_CASE       803
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 804 */
+#if     ((804 >= GSL_INCLUDER_FIRST_CASE) && (804 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (804)))
+#define  GSL_INCLUDER_CASE       804
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 805 */
+#if     ((805 >= GSL_INCLUDER_FIRST_CASE) && (805 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (805)))
+#define  GSL_INCLUDER_CASE       805
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 806 */
+#if     ((806 >= GSL_INCLUDER_FIRST_CASE) && (806 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (806)))
+#define  GSL_INCLUDER_CASE       806
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 807 */
+#if     ((807 >= GSL_INCLUDER_FIRST_CASE) && (807 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (807)))
+#define  GSL_INCLUDER_CASE       807
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 808 */
+#if     ((808 >= GSL_INCLUDER_FIRST_CASE) && (808 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (808)))
+#define  GSL_INCLUDER_CASE       808
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 809 */
+#if     ((809 >= GSL_INCLUDER_FIRST_CASE) && (809 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (809)))
+#define  GSL_INCLUDER_CASE       809
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 810 */
+#if     ((810 >= GSL_INCLUDER_FIRST_CASE) && (810 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (810)))
+#define  GSL_INCLUDER_CASE       810
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 811 */
+#if     ((811 >= GSL_INCLUDER_FIRST_CASE) && (811 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (811)))
+#define  GSL_INCLUDER_CASE       811
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 812 */
+#if     ((812 >= GSL_INCLUDER_FIRST_CASE) && (812 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (812)))
+#define  GSL_INCLUDER_CASE       812
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 813 */
+#if     ((813 >= GSL_INCLUDER_FIRST_CASE) && (813 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (813)))
+#define  GSL_INCLUDER_CASE       813
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 814 */
+#if     ((814 >= GSL_INCLUDER_FIRST_CASE) && (814 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (814)))
+#define  GSL_INCLUDER_CASE       814
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 815 */
+#if     ((815 >= GSL_INCLUDER_FIRST_CASE) && (815 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (815)))
+#define  GSL_INCLUDER_CASE       815
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 816 */
+#if     ((816 >= GSL_INCLUDER_FIRST_CASE) && (816 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (816)))
+#define  GSL_INCLUDER_CASE       816
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 817 */
+#if     ((817 >= GSL_INCLUDER_FIRST_CASE) && (817 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (817)))
+#define  GSL_INCLUDER_CASE       817
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 818 */
+#if     ((818 >= GSL_INCLUDER_FIRST_CASE) && (818 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (818)))
+#define  GSL_INCLUDER_CASE       818
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 819 */
+#if     ((819 >= GSL_INCLUDER_FIRST_CASE) && (819 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (819)))
+#define  GSL_INCLUDER_CASE       819
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 820 */
+#if     ((820 >= GSL_INCLUDER_FIRST_CASE) && (820 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (820)))
+#define  GSL_INCLUDER_CASE       820
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 821 */
+#if     ((821 >= GSL_INCLUDER_FIRST_CASE) && (821 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (821)))
+#define  GSL_INCLUDER_CASE       821
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 822 */
+#if     ((822 >= GSL_INCLUDER_FIRST_CASE) && (822 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (822)))
+#define  GSL_INCLUDER_CASE       822
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 823 */
+#if     ((823 >= GSL_INCLUDER_FIRST_CASE) && (823 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (823)))
+#define  GSL_INCLUDER_CASE       823
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 824 */
+#if     ((824 >= GSL_INCLUDER_FIRST_CASE) && (824 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (824)))
+#define  GSL_INCLUDER_CASE       824
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 825 */
+#if     ((825 >= GSL_INCLUDER_FIRST_CASE) && (825 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (825)))
+#define  GSL_INCLUDER_CASE       825
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 826 */
+#if     ((826 >= GSL_INCLUDER_FIRST_CASE) && (826 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (826)))
+#define  GSL_INCLUDER_CASE       826
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 827 */
+#if     ((827 >= GSL_INCLUDER_FIRST_CASE) && (827 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (827)))
+#define  GSL_INCLUDER_CASE       827
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 828 */
+#if     ((828 >= GSL_INCLUDER_FIRST_CASE) && (828 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (828)))
+#define  GSL_INCLUDER_CASE       828
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 829 */
+#if     ((829 >= GSL_INCLUDER_FIRST_CASE) && (829 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (829)))
+#define  GSL_INCLUDER_CASE       829
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 830 */
+#if     ((830 >= GSL_INCLUDER_FIRST_CASE) && (830 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (830)))
+#define  GSL_INCLUDER_CASE       830
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 831 */
+#if     ((831 >= GSL_INCLUDER_FIRST_CASE) && (831 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (831)))
+#define  GSL_INCLUDER_CASE       831
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 832 */
+#if     ((832 >= GSL_INCLUDER_FIRST_CASE) && (832 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (832)))
+#define  GSL_INCLUDER_CASE       832
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 833 */
+#if     ((833 >= GSL_INCLUDER_FIRST_CASE) && (833 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (833)))
+#define  GSL_INCLUDER_CASE       833
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 834 */
+#if     ((834 >= GSL_INCLUDER_FIRST_CASE) && (834 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (834)))
+#define  GSL_INCLUDER_CASE       834
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 835 */
+#if     ((835 >= GSL_INCLUDER_FIRST_CASE) && (835 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (835)))
+#define  GSL_INCLUDER_CASE       835
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 836 */
+#if     ((836 >= GSL_INCLUDER_FIRST_CASE) && (836 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (836)))
+#define  GSL_INCLUDER_CASE       836
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 837 */
+#if     ((837 >= GSL_INCLUDER_FIRST_CASE) && (837 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (837)))
+#define  GSL_INCLUDER_CASE       837
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 838 */
+#if     ((838 >= GSL_INCLUDER_FIRST_CASE) && (838 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (838)))
+#define  GSL_INCLUDER_CASE       838
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 839 */
+#if     ((839 >= GSL_INCLUDER_FIRST_CASE) && (839 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (839)))
+#define  GSL_INCLUDER_CASE       839
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 840 */
+#if     ((840 >= GSL_INCLUDER_FIRST_CASE) && (840 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (840)))
+#define  GSL_INCLUDER_CASE       840
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 841 */
+#if     ((841 >= GSL_INCLUDER_FIRST_CASE) && (841 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (841)))
+#define  GSL_INCLUDER_CASE       841
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 842 */
+#if     ((842 >= GSL_INCLUDER_FIRST_CASE) && (842 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (842)))
+#define  GSL_INCLUDER_CASE       842
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 843 */
+#if     ((843 >= GSL_INCLUDER_FIRST_CASE) && (843 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (843)))
+#define  GSL_INCLUDER_CASE       843
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 844 */
+#if     ((844 >= GSL_INCLUDER_FIRST_CASE) && (844 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (844)))
+#define  GSL_INCLUDER_CASE       844
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 845 */
+#if     ((845 >= GSL_INCLUDER_FIRST_CASE) && (845 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (845)))
+#define  GSL_INCLUDER_CASE       845
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 846 */
+#if     ((846 >= GSL_INCLUDER_FIRST_CASE) && (846 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (846)))
+#define  GSL_INCLUDER_CASE       846
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 847 */
+#if     ((847 >= GSL_INCLUDER_FIRST_CASE) && (847 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (847)))
+#define  GSL_INCLUDER_CASE       847
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 848 */
+#if     ((848 >= GSL_INCLUDER_FIRST_CASE) && (848 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (848)))
+#define  GSL_INCLUDER_CASE       848
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 849 */
+#if     ((849 >= GSL_INCLUDER_FIRST_CASE) && (849 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (849)))
+#define  GSL_INCLUDER_CASE       849
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 850 */
+#if     ((850 >= GSL_INCLUDER_FIRST_CASE) && (850 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (850)))
+#define  GSL_INCLUDER_CASE       850
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 851 */
+#if     ((851 >= GSL_INCLUDER_FIRST_CASE) && (851 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (851)))
+#define  GSL_INCLUDER_CASE       851
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 852 */
+#if     ((852 >= GSL_INCLUDER_FIRST_CASE) && (852 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (852)))
+#define  GSL_INCLUDER_CASE       852
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 853 */
+#if     ((853 >= GSL_INCLUDER_FIRST_CASE) && (853 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (853)))
+#define  GSL_INCLUDER_CASE       853
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 854 */
+#if     ((854 >= GSL_INCLUDER_FIRST_CASE) && (854 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (854)))
+#define  GSL_INCLUDER_CASE       854
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 855 */
+#if     ((855 >= GSL_INCLUDER_FIRST_CASE) && (855 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (855)))
+#define  GSL_INCLUDER_CASE       855
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 856 */
+#if     ((856 >= GSL_INCLUDER_FIRST_CASE) && (856 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (856)))
+#define  GSL_INCLUDER_CASE       856
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 857 */
+#if     ((857 >= GSL_INCLUDER_FIRST_CASE) && (857 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (857)))
+#define  GSL_INCLUDER_CASE       857
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 858 */
+#if     ((858 >= GSL_INCLUDER_FIRST_CASE) && (858 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (858)))
+#define  GSL_INCLUDER_CASE       858
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 859 */
+#if     ((859 >= GSL_INCLUDER_FIRST_CASE) && (859 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (859)))
+#define  GSL_INCLUDER_CASE       859
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 860 */
+#if     ((860 >= GSL_INCLUDER_FIRST_CASE) && (860 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (860)))
+#define  GSL_INCLUDER_CASE       860
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 861 */
+#if     ((861 >= GSL_INCLUDER_FIRST_CASE) && (861 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (861)))
+#define  GSL_INCLUDER_CASE       861
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 862 */
+#if     ((862 >= GSL_INCLUDER_FIRST_CASE) && (862 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (862)))
+#define  GSL_INCLUDER_CASE       862
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 863 */
+#if     ((863 >= GSL_INCLUDER_FIRST_CASE) && (863 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (863)))
+#define  GSL_INCLUDER_CASE       863
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 864 */
+#if     ((864 >= GSL_INCLUDER_FIRST_CASE) && (864 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (864)))
+#define  GSL_INCLUDER_CASE       864
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 865 */
+#if     ((865 >= GSL_INCLUDER_FIRST_CASE) && (865 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (865)))
+#define  GSL_INCLUDER_CASE       865
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 866 */
+#if     ((866 >= GSL_INCLUDER_FIRST_CASE) && (866 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (866)))
+#define  GSL_INCLUDER_CASE       866
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 867 */
+#if     ((867 >= GSL_INCLUDER_FIRST_CASE) && (867 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (867)))
+#define  GSL_INCLUDER_CASE       867
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 868 */
+#if     ((868 >= GSL_INCLUDER_FIRST_CASE) && (868 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (868)))
+#define  GSL_INCLUDER_CASE       868
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 869 */
+#if     ((869 >= GSL_INCLUDER_FIRST_CASE) && (869 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (869)))
+#define  GSL_INCLUDER_CASE       869
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 870 */
+#if     ((870 >= GSL_INCLUDER_FIRST_CASE) && (870 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (870)))
+#define  GSL_INCLUDER_CASE       870
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 871 */
+#if     ((871 >= GSL_INCLUDER_FIRST_CASE) && (871 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (871)))
+#define  GSL_INCLUDER_CASE       871
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 872 */
+#if     ((872 >= GSL_INCLUDER_FIRST_CASE) && (872 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (872)))
+#define  GSL_INCLUDER_CASE       872
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 873 */
+#if     ((873 >= GSL_INCLUDER_FIRST_CASE) && (873 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (873)))
+#define  GSL_INCLUDER_CASE       873
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 874 */
+#if     ((874 >= GSL_INCLUDER_FIRST_CASE) && (874 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (874)))
+#define  GSL_INCLUDER_CASE       874
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 875 */
+#if     ((875 >= GSL_INCLUDER_FIRST_CASE) && (875 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (875)))
+#define  GSL_INCLUDER_CASE       875
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 876 */
+#if     ((876 >= GSL_INCLUDER_FIRST_CASE) && (876 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (876)))
+#define  GSL_INCLUDER_CASE       876
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 877 */
+#if     ((877 >= GSL_INCLUDER_FIRST_CASE) && (877 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (877)))
+#define  GSL_INCLUDER_CASE       877
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 878 */
+#if     ((878 >= GSL_INCLUDER_FIRST_CASE) && (878 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (878)))
+#define  GSL_INCLUDER_CASE       878
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 879 */
+#if     ((879 >= GSL_INCLUDER_FIRST_CASE) && (879 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (879)))
+#define  GSL_INCLUDER_CASE       879
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 880 */
+#if     ((880 >= GSL_INCLUDER_FIRST_CASE) && (880 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (880)))
+#define  GSL_INCLUDER_CASE       880
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 881 */
+#if     ((881 >= GSL_INCLUDER_FIRST_CASE) && (881 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (881)))
+#define  GSL_INCLUDER_CASE       881
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 882 */
+#if     ((882 >= GSL_INCLUDER_FIRST_CASE) && (882 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (882)))
+#define  GSL_INCLUDER_CASE       882
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 883 */
+#if     ((883 >= GSL_INCLUDER_FIRST_CASE) && (883 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (883)))
+#define  GSL_INCLUDER_CASE       883
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 884 */
+#if     ((884 >= GSL_INCLUDER_FIRST_CASE) && (884 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (884)))
+#define  GSL_INCLUDER_CASE       884
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 885 */
+#if     ((885 >= GSL_INCLUDER_FIRST_CASE) && (885 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (885)))
+#define  GSL_INCLUDER_CASE       885
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 886 */
+#if     ((886 >= GSL_INCLUDER_FIRST_CASE) && (886 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (886)))
+#define  GSL_INCLUDER_CASE       886
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 887 */
+#if     ((887 >= GSL_INCLUDER_FIRST_CASE) && (887 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (887)))
+#define  GSL_INCLUDER_CASE       887
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 888 */
+#if     ((888 >= GSL_INCLUDER_FIRST_CASE) && (888 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (888)))
+#define  GSL_INCLUDER_CASE       888
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 889 */
+#if     ((889 >= GSL_INCLUDER_FIRST_CASE) && (889 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (889)))
+#define  GSL_INCLUDER_CASE       889
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 890 */
+#if     ((890 >= GSL_INCLUDER_FIRST_CASE) && (890 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (890)))
+#define  GSL_INCLUDER_CASE       890
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 891 */
+#if     ((891 >= GSL_INCLUDER_FIRST_CASE) && (891 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (891)))
+#define  GSL_INCLUDER_CASE       891
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 892 */
+#if     ((892 >= GSL_INCLUDER_FIRST_CASE) && (892 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (892)))
+#define  GSL_INCLUDER_CASE       892
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 893 */
+#if     ((893 >= GSL_INCLUDER_FIRST_CASE) && (893 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (893)))
+#define  GSL_INCLUDER_CASE       893
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 894 */
+#if     ((894 >= GSL_INCLUDER_FIRST_CASE) && (894 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (894)))
+#define  GSL_INCLUDER_CASE       894
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 895 */
+#if     ((895 >= GSL_INCLUDER_FIRST_CASE) && (895 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (895)))
+#define  GSL_INCLUDER_CASE       895
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 896 */
+#if     ((896 >= GSL_INCLUDER_FIRST_CASE) && (896 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (896)))
+#define  GSL_INCLUDER_CASE       896
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 897 */
+#if     ((897 >= GSL_INCLUDER_FIRST_CASE) && (897 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (897)))
+#define  GSL_INCLUDER_CASE       897
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 898 */
+#if     ((898 >= GSL_INCLUDER_FIRST_CASE) && (898 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (898)))
+#define  GSL_INCLUDER_CASE       898
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 899 */
+#if     ((899 >= GSL_INCLUDER_FIRST_CASE) && (899 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (899)))
+#define  GSL_INCLUDER_CASE       899
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 900 */
+#if     ((900 >= GSL_INCLUDER_FIRST_CASE) && (900 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (900)))
+#define  GSL_INCLUDER_CASE       900
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 901 */
+#if     ((901 >= GSL_INCLUDER_FIRST_CASE) && (901 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (901)))
+#define  GSL_INCLUDER_CASE       901
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 902 */
+#if     ((902 >= GSL_INCLUDER_FIRST_CASE) && (902 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (902)))
+#define  GSL_INCLUDER_CASE       902
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 903 */
+#if     ((903 >= GSL_INCLUDER_FIRST_CASE) && (903 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (903)))
+#define  GSL_INCLUDER_CASE       903
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 904 */
+#if     ((904 >= GSL_INCLUDER_FIRST_CASE) && (904 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (904)))
+#define  GSL_INCLUDER_CASE       904
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 905 */
+#if     ((905 >= GSL_INCLUDER_FIRST_CASE) && (905 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (905)))
+#define  GSL_INCLUDER_CASE       905
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 906 */
+#if     ((906 >= GSL_INCLUDER_FIRST_CASE) && (906 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (906)))
+#define  GSL_INCLUDER_CASE       906
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 907 */
+#if     ((907 >= GSL_INCLUDER_FIRST_CASE) && (907 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (907)))
+#define  GSL_INCLUDER_CASE       907
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 908 */
+#if     ((908 >= GSL_INCLUDER_FIRST_CASE) && (908 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (908)))
+#define  GSL_INCLUDER_CASE       908
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 909 */
+#if     ((909 >= GSL_INCLUDER_FIRST_CASE) && (909 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (909)))
+#define  GSL_INCLUDER_CASE       909
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 910 */
+#if     ((910 >= GSL_INCLUDER_FIRST_CASE) && (910 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (910)))
+#define  GSL_INCLUDER_CASE       910
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 911 */
+#if     ((911 >= GSL_INCLUDER_FIRST_CASE) && (911 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (911)))
+#define  GSL_INCLUDER_CASE       911
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 912 */
+#if     ((912 >= GSL_INCLUDER_FIRST_CASE) && (912 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (912)))
+#define  GSL_INCLUDER_CASE       912
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 913 */
+#if     ((913 >= GSL_INCLUDER_FIRST_CASE) && (913 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (913)))
+#define  GSL_INCLUDER_CASE       913
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 914 */
+#if     ((914 >= GSL_INCLUDER_FIRST_CASE) && (914 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (914)))
+#define  GSL_INCLUDER_CASE       914
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 915 */
+#if     ((915 >= GSL_INCLUDER_FIRST_CASE) && (915 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (915)))
+#define  GSL_INCLUDER_CASE       915
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 916 */
+#if     ((916 >= GSL_INCLUDER_FIRST_CASE) && (916 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (916)))
+#define  GSL_INCLUDER_CASE       916
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 917 */
+#if     ((917 >= GSL_INCLUDER_FIRST_CASE) && (917 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (917)))
+#define  GSL_INCLUDER_CASE       917
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 918 */
+#if     ((918 >= GSL_INCLUDER_FIRST_CASE) && (918 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (918)))
+#define  GSL_INCLUDER_CASE       918
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 919 */
+#if     ((919 >= GSL_INCLUDER_FIRST_CASE) && (919 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (919)))
+#define  GSL_INCLUDER_CASE       919
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 920 */
+#if     ((920 >= GSL_INCLUDER_FIRST_CASE) && (920 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (920)))
+#define  GSL_INCLUDER_CASE       920
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 921 */
+#if     ((921 >= GSL_INCLUDER_FIRST_CASE) && (921 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (921)))
+#define  GSL_INCLUDER_CASE       921
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 922 */
+#if     ((922 >= GSL_INCLUDER_FIRST_CASE) && (922 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (922)))
+#define  GSL_INCLUDER_CASE       922
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 923 */
+#if     ((923 >= GSL_INCLUDER_FIRST_CASE) && (923 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (923)))
+#define  GSL_INCLUDER_CASE       923
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 924 */
+#if     ((924 >= GSL_INCLUDER_FIRST_CASE) && (924 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (924)))
+#define  GSL_INCLUDER_CASE       924
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 925 */
+#if     ((925 >= GSL_INCLUDER_FIRST_CASE) && (925 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (925)))
+#define  GSL_INCLUDER_CASE       925
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 926 */
+#if     ((926 >= GSL_INCLUDER_FIRST_CASE) && (926 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (926)))
+#define  GSL_INCLUDER_CASE       926
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 927 */
+#if     ((927 >= GSL_INCLUDER_FIRST_CASE) && (927 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (927)))
+#define  GSL_INCLUDER_CASE       927
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 928 */
+#if     ((928 >= GSL_INCLUDER_FIRST_CASE) && (928 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (928)))
+#define  GSL_INCLUDER_CASE       928
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 929 */
+#if     ((929 >= GSL_INCLUDER_FIRST_CASE) && (929 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (929)))
+#define  GSL_INCLUDER_CASE       929
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 930 */
+#if     ((930 >= GSL_INCLUDER_FIRST_CASE) && (930 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (930)))
+#define  GSL_INCLUDER_CASE       930
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 931 */
+#if     ((931 >= GSL_INCLUDER_FIRST_CASE) && (931 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (931)))
+#define  GSL_INCLUDER_CASE       931
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 932 */
+#if     ((932 >= GSL_INCLUDER_FIRST_CASE) && (932 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (932)))
+#define  GSL_INCLUDER_CASE       932
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 933 */
+#if     ((933 >= GSL_INCLUDER_FIRST_CASE) && (933 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (933)))
+#define  GSL_INCLUDER_CASE       933
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 934 */
+#if     ((934 >= GSL_INCLUDER_FIRST_CASE) && (934 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (934)))
+#define  GSL_INCLUDER_CASE       934
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 935 */
+#if     ((935 >= GSL_INCLUDER_FIRST_CASE) && (935 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (935)))
+#define  GSL_INCLUDER_CASE       935
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 936 */
+#if     ((936 >= GSL_INCLUDER_FIRST_CASE) && (936 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (936)))
+#define  GSL_INCLUDER_CASE       936
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 937 */
+#if     ((937 >= GSL_INCLUDER_FIRST_CASE) && (937 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (937)))
+#define  GSL_INCLUDER_CASE       937
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 938 */
+#if     ((938 >= GSL_INCLUDER_FIRST_CASE) && (938 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (938)))
+#define  GSL_INCLUDER_CASE       938
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 939 */
+#if     ((939 >= GSL_INCLUDER_FIRST_CASE) && (939 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (939)))
+#define  GSL_INCLUDER_CASE       939
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 940 */
+#if     ((940 >= GSL_INCLUDER_FIRST_CASE) && (940 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (940)))
+#define  GSL_INCLUDER_CASE       940
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 941 */
+#if     ((941 >= GSL_INCLUDER_FIRST_CASE) && (941 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (941)))
+#define  GSL_INCLUDER_CASE       941
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 942 */
+#if     ((942 >= GSL_INCLUDER_FIRST_CASE) && (942 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (942)))
+#define  GSL_INCLUDER_CASE       942
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 943 */
+#if     ((943 >= GSL_INCLUDER_FIRST_CASE) && (943 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (943)))
+#define  GSL_INCLUDER_CASE       943
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 944 */
+#if     ((944 >= GSL_INCLUDER_FIRST_CASE) && (944 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (944)))
+#define  GSL_INCLUDER_CASE       944
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 945 */
+#if     ((945 >= GSL_INCLUDER_FIRST_CASE) && (945 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (945)))
+#define  GSL_INCLUDER_CASE       945
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 946 */
+#if     ((946 >= GSL_INCLUDER_FIRST_CASE) && (946 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (946)))
+#define  GSL_INCLUDER_CASE       946
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 947 */
+#if     ((947 >= GSL_INCLUDER_FIRST_CASE) && (947 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (947)))
+#define  GSL_INCLUDER_CASE       947
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 948 */
+#if     ((948 >= GSL_INCLUDER_FIRST_CASE) && (948 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (948)))
+#define  GSL_INCLUDER_CASE       948
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 949 */
+#if     ((949 >= GSL_INCLUDER_FIRST_CASE) && (949 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (949)))
+#define  GSL_INCLUDER_CASE       949
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 950 */
+#if     ((950 >= GSL_INCLUDER_FIRST_CASE) && (950 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (950)))
+#define  GSL_INCLUDER_CASE       950
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 951 */
+#if     ((951 >= GSL_INCLUDER_FIRST_CASE) && (951 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (951)))
+#define  GSL_INCLUDER_CASE       951
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 952 */
+#if     ((952 >= GSL_INCLUDER_FIRST_CASE) && (952 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (952)))
+#define  GSL_INCLUDER_CASE       952
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 953 */
+#if     ((953 >= GSL_INCLUDER_FIRST_CASE) && (953 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (953)))
+#define  GSL_INCLUDER_CASE       953
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 954 */
+#if     ((954 >= GSL_INCLUDER_FIRST_CASE) && (954 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (954)))
+#define  GSL_INCLUDER_CASE       954
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 955 */
+#if     ((955 >= GSL_INCLUDER_FIRST_CASE) && (955 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (955)))
+#define  GSL_INCLUDER_CASE       955
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 956 */
+#if     ((956 >= GSL_INCLUDER_FIRST_CASE) && (956 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (956)))
+#define  GSL_INCLUDER_CASE       956
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 957 */
+#if     ((957 >= GSL_INCLUDER_FIRST_CASE) && (957 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (957)))
+#define  GSL_INCLUDER_CASE       957
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 958 */
+#if     ((958 >= GSL_INCLUDER_FIRST_CASE) && (958 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (958)))
+#define  GSL_INCLUDER_CASE       958
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 959 */
+#if     ((959 >= GSL_INCLUDER_FIRST_CASE) && (959 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (959)))
+#define  GSL_INCLUDER_CASE       959
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 960 */
+#if     ((960 >= GSL_INCLUDER_FIRST_CASE) && (960 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (960)))
+#define  GSL_INCLUDER_CASE       960
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 961 */
+#if     ((961 >= GSL_INCLUDER_FIRST_CASE) && (961 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (961)))
+#define  GSL_INCLUDER_CASE       961
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 962 */
+#if     ((962 >= GSL_INCLUDER_FIRST_CASE) && (962 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (962)))
+#define  GSL_INCLUDER_CASE       962
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 963 */
+#if     ((963 >= GSL_INCLUDER_FIRST_CASE) && (963 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (963)))
+#define  GSL_INCLUDER_CASE       963
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 964 */
+#if     ((964 >= GSL_INCLUDER_FIRST_CASE) && (964 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (964)))
+#define  GSL_INCLUDER_CASE       964
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 965 */
+#if     ((965 >= GSL_INCLUDER_FIRST_CASE) && (965 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (965)))
+#define  GSL_INCLUDER_CASE       965
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 966 */
+#if     ((966 >= GSL_INCLUDER_FIRST_CASE) && (966 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (966)))
+#define  GSL_INCLUDER_CASE       966
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 967 */
+#if     ((967 >= GSL_INCLUDER_FIRST_CASE) && (967 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (967)))
+#define  GSL_INCLUDER_CASE       967
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 968 */
+#if     ((968 >= GSL_INCLUDER_FIRST_CASE) && (968 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (968)))
+#define  GSL_INCLUDER_CASE       968
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 969 */
+#if     ((969 >= GSL_INCLUDER_FIRST_CASE) && (969 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (969)))
+#define  GSL_INCLUDER_CASE       969
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 970 */
+#if     ((970 >= GSL_INCLUDER_FIRST_CASE) && (970 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (970)))
+#define  GSL_INCLUDER_CASE       970
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 971 */
+#if     ((971 >= GSL_INCLUDER_FIRST_CASE) && (971 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (971)))
+#define  GSL_INCLUDER_CASE       971
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 972 */
+#if     ((972 >= GSL_INCLUDER_FIRST_CASE) && (972 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (972)))
+#define  GSL_INCLUDER_CASE       972
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 973 */
+#if     ((973 >= GSL_INCLUDER_FIRST_CASE) && (973 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (973)))
+#define  GSL_INCLUDER_CASE       973
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 974 */
+#if     ((974 >= GSL_INCLUDER_FIRST_CASE) && (974 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (974)))
+#define  GSL_INCLUDER_CASE       974
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 975 */
+#if     ((975 >= GSL_INCLUDER_FIRST_CASE) && (975 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (975)))
+#define  GSL_INCLUDER_CASE       975
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 976 */
+#if     ((976 >= GSL_INCLUDER_FIRST_CASE) && (976 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (976)))
+#define  GSL_INCLUDER_CASE       976
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 977 */
+#if     ((977 >= GSL_INCLUDER_FIRST_CASE) && (977 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (977)))
+#define  GSL_INCLUDER_CASE       977
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 978 */
+#if     ((978 >= GSL_INCLUDER_FIRST_CASE) && (978 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (978)))
+#define  GSL_INCLUDER_CASE       978
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 979 */
+#if     ((979 >= GSL_INCLUDER_FIRST_CASE) && (979 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (979)))
+#define  GSL_INCLUDER_CASE       979
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 980 */
+#if     ((980 >= GSL_INCLUDER_FIRST_CASE) && (980 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (980)))
+#define  GSL_INCLUDER_CASE       980
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 981 */
+#if     ((981 >= GSL_INCLUDER_FIRST_CASE) && (981 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (981)))
+#define  GSL_INCLUDER_CASE       981
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 982 */
+#if     ((982 >= GSL_INCLUDER_FIRST_CASE) && (982 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (982)))
+#define  GSL_INCLUDER_CASE       982
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 983 */
+#if     ((983 >= GSL_INCLUDER_FIRST_CASE) && (983 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (983)))
+#define  GSL_INCLUDER_CASE       983
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 984 */
+#if     ((984 >= GSL_INCLUDER_FIRST_CASE) && (984 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (984)))
+#define  GSL_INCLUDER_CASE       984
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 985 */
+#if     ((985 >= GSL_INCLUDER_FIRST_CASE) && (985 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (985)))
+#define  GSL_INCLUDER_CASE       985
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 986 */
+#if     ((986 >= GSL_INCLUDER_FIRST_CASE) && (986 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (986)))
+#define  GSL_INCLUDER_CASE       986
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 987 */
+#if     ((987 >= GSL_INCLUDER_FIRST_CASE) && (987 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (987)))
+#define  GSL_INCLUDER_CASE       987
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 988 */
+#if     ((988 >= GSL_INCLUDER_FIRST_CASE) && (988 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (988)))
+#define  GSL_INCLUDER_CASE       988
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 989 */
+#if     ((989 >= GSL_INCLUDER_FIRST_CASE) && (989 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (989)))
+#define  GSL_INCLUDER_CASE       989
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 990 */
+#if     ((990 >= GSL_INCLUDER_FIRST_CASE) && (990 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (990)))
+#define  GSL_INCLUDER_CASE       990
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 991 */
+#if     ((991 >= GSL_INCLUDER_FIRST_CASE) && (991 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (991)))
+#define  GSL_INCLUDER_CASE       991
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 992 */
+#if     ((992 >= GSL_INCLUDER_FIRST_CASE) && (992 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (992)))
+#define  GSL_INCLUDER_CASE       992
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 993 */
+#if     ((993 >= GSL_INCLUDER_FIRST_CASE) && (993 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (993)))
+#define  GSL_INCLUDER_CASE       993
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 994 */
+#if     ((994 >= GSL_INCLUDER_FIRST_CASE) && (994 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (994)))
+#define  GSL_INCLUDER_CASE       994
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 995 */
+#if     ((995 >= GSL_INCLUDER_FIRST_CASE) && (995 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (995)))
+#define  GSL_INCLUDER_CASE       995
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 996 */
+#if     ((996 >= GSL_INCLUDER_FIRST_CASE) && (996 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (996)))
+#define  GSL_INCLUDER_CASE       996
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 997 */
+#if     ((997 >= GSL_INCLUDER_FIRST_CASE) && (997 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (997)))
+#define  GSL_INCLUDER_CASE       997
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 998 */
+#if     ((998 >= GSL_INCLUDER_FIRST_CASE) && (998 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (998)))
+#define  GSL_INCLUDER_CASE       998
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 999 */
+#if     ((999 >= GSL_INCLUDER_FIRST_CASE) && (999 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (999)))
+#define  GSL_INCLUDER_CASE       999
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1000 */
+#if     ((1000 >= GSL_INCLUDER_FIRST_CASE) && (1000 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1000)))
+#define  GSL_INCLUDER_CASE       1000
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1001 */
+#if     ((1001 >= GSL_INCLUDER_FIRST_CASE) && (1001 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1001)))
+#define  GSL_INCLUDER_CASE       1001
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1002 */
+#if     ((1002 >= GSL_INCLUDER_FIRST_CASE) && (1002 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1002)))
+#define  GSL_INCLUDER_CASE       1002
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1003 */
+#if     ((1003 >= GSL_INCLUDER_FIRST_CASE) && (1003 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1003)))
+#define  GSL_INCLUDER_CASE       1003
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1004 */
+#if     ((1004 >= GSL_INCLUDER_FIRST_CASE) && (1004 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1004)))
+#define  GSL_INCLUDER_CASE       1004
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1005 */
+#if     ((1005 >= GSL_INCLUDER_FIRST_CASE) && (1005 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1005)))
+#define  GSL_INCLUDER_CASE       1005
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1006 */
+#if     ((1006 >= GSL_INCLUDER_FIRST_CASE) && (1006 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1006)))
+#define  GSL_INCLUDER_CASE       1006
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1007 */
+#if     ((1007 >= GSL_INCLUDER_FIRST_CASE) && (1007 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1007)))
+#define  GSL_INCLUDER_CASE       1007
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1008 */
+#if     ((1008 >= GSL_INCLUDER_FIRST_CASE) && (1008 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1008)))
+#define  GSL_INCLUDER_CASE       1008
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1009 */
+#if     ((1009 >= GSL_INCLUDER_FIRST_CASE) && (1009 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1009)))
+#define  GSL_INCLUDER_CASE       1009
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1010 */
+#if     ((1010 >= GSL_INCLUDER_FIRST_CASE) && (1010 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1010)))
+#define  GSL_INCLUDER_CASE       1010
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1011 */
+#if     ((1011 >= GSL_INCLUDER_FIRST_CASE) && (1011 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1011)))
+#define  GSL_INCLUDER_CASE       1011
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1012 */
+#if     ((1012 >= GSL_INCLUDER_FIRST_CASE) && (1012 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1012)))
+#define  GSL_INCLUDER_CASE       1012
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1013 */
+#if     ((1013 >= GSL_INCLUDER_FIRST_CASE) && (1013 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1013)))
+#define  GSL_INCLUDER_CASE       1013
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1014 */
+#if     ((1014 >= GSL_INCLUDER_FIRST_CASE) && (1014 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1014)))
+#define  GSL_INCLUDER_CASE       1014
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1015 */
+#if     ((1015 >= GSL_INCLUDER_FIRST_CASE) && (1015 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1015)))
+#define  GSL_INCLUDER_CASE       1015
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1016 */
+#if     ((1016 >= GSL_INCLUDER_FIRST_CASE) && (1016 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1016)))
+#define  GSL_INCLUDER_CASE       1016
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1017 */
+#if     ((1017 >= GSL_INCLUDER_FIRST_CASE) && (1017 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1017)))
+#define  GSL_INCLUDER_CASE       1017
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1018 */
+#if     ((1018 >= GSL_INCLUDER_FIRST_CASE) && (1018 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1018)))
+#define  GSL_INCLUDER_CASE       1018
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1019 */
+#if     ((1019 >= GSL_INCLUDER_FIRST_CASE) && (1019 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1019)))
+#define  GSL_INCLUDER_CASE       1019
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1020 */
+#if     ((1020 >= GSL_INCLUDER_FIRST_CASE) && (1020 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1020)))
+#define  GSL_INCLUDER_CASE       1020
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1021 */
+#if     ((1021 >= GSL_INCLUDER_FIRST_CASE) && (1021 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1021)))
+#define  GSL_INCLUDER_CASE       1021
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1022 */
+#if     ((1022 >= GSL_INCLUDER_FIRST_CASE) && (1022 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1022)))
+#define  GSL_INCLUDER_CASE       1022
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1023 */
+#if     ((1023 >= GSL_INCLUDER_FIRST_CASE) && (1023 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1023)))
+#define  GSL_INCLUDER_CASE       1023
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+/* 1024 */
+#if     ((1024 >= GSL_INCLUDER_FIRST_CASE) && (1024 <= GSL_INCLUDER_LAST_CASE) && !(GSL_INCLUDER_REJECT (1024)))
+#define  GSL_INCLUDER_CASE       1024
+#include GSL_INCLUDER_FILE
+#undef   GSL_INCLUDER_CASE
+#endif
+
+GSL_INCLUDER_TABLE = {
+#if     ((0 >= GSL_INCLUDER_FIRST_CASE) && (0 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (0))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 0),
+#endif
+#endif
+#if     ((1 >= GSL_INCLUDER_FIRST_CASE) && (1 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1),
+#endif
+#endif
+#if     ((2 >= GSL_INCLUDER_FIRST_CASE) && (2 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (2))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 2),
+#endif
+#endif
+#if     ((3 >= GSL_INCLUDER_FIRST_CASE) && (3 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (3))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 3),
+#endif
+#endif
+#if     ((4 >= GSL_INCLUDER_FIRST_CASE) && (4 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (4))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 4),
+#endif
+#endif
+#if     ((5 >= GSL_INCLUDER_FIRST_CASE) && (5 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (5))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 5),
+#endif
+#endif
+#if     ((6 >= GSL_INCLUDER_FIRST_CASE) && (6 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (6))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 6),
+#endif
+#endif
+#if     ((7 >= GSL_INCLUDER_FIRST_CASE) && (7 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (7))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 7),
+#endif
+#endif
+#if     ((8 >= GSL_INCLUDER_FIRST_CASE) && (8 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (8))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 8),
+#endif
+#endif
+#if     ((9 >= GSL_INCLUDER_FIRST_CASE) && (9 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (9))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 9),
+#endif
+#endif
+#if     ((10 >= GSL_INCLUDER_FIRST_CASE) && (10 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (10))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 10),
+#endif
+#endif
+#if     ((11 >= GSL_INCLUDER_FIRST_CASE) && (11 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (11))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 11),
+#endif
+#endif
+#if     ((12 >= GSL_INCLUDER_FIRST_CASE) && (12 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (12))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 12),
+#endif
+#endif
+#if     ((13 >= GSL_INCLUDER_FIRST_CASE) && (13 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (13))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 13),
+#endif
+#endif
+#if     ((14 >= GSL_INCLUDER_FIRST_CASE) && (14 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (14))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 14),
+#endif
+#endif
+#if     ((15 >= GSL_INCLUDER_FIRST_CASE) && (15 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (15))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 15),
+#endif
+#endif
+#if     ((16 >= GSL_INCLUDER_FIRST_CASE) && (16 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (16))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 16),
+#endif
+#endif
+#if     ((17 >= GSL_INCLUDER_FIRST_CASE) && (17 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (17))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 17),
+#endif
+#endif
+#if     ((18 >= GSL_INCLUDER_FIRST_CASE) && (18 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (18))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 18),
+#endif
+#endif
+#if     ((19 >= GSL_INCLUDER_FIRST_CASE) && (19 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (19))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 19),
+#endif
+#endif
+#if     ((20 >= GSL_INCLUDER_FIRST_CASE) && (20 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (20))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 20),
+#endif
+#endif
+#if     ((21 >= GSL_INCLUDER_FIRST_CASE) && (21 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (21))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 21),
+#endif
+#endif
+#if     ((22 >= GSL_INCLUDER_FIRST_CASE) && (22 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (22))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 22),
+#endif
+#endif
+#if     ((23 >= GSL_INCLUDER_FIRST_CASE) && (23 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (23))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 23),
+#endif
+#endif
+#if     ((24 >= GSL_INCLUDER_FIRST_CASE) && (24 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (24))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 24),
+#endif
+#endif
+#if     ((25 >= GSL_INCLUDER_FIRST_CASE) && (25 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (25))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 25),
+#endif
+#endif
+#if     ((26 >= GSL_INCLUDER_FIRST_CASE) && (26 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (26))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 26),
+#endif
+#endif
+#if     ((27 >= GSL_INCLUDER_FIRST_CASE) && (27 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (27))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 27),
+#endif
+#endif
+#if     ((28 >= GSL_INCLUDER_FIRST_CASE) && (28 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (28))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 28),
+#endif
+#endif
+#if     ((29 >= GSL_INCLUDER_FIRST_CASE) && (29 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (29))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 29),
+#endif
+#endif
+#if     ((30 >= GSL_INCLUDER_FIRST_CASE) && (30 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (30))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 30),
+#endif
+#endif
+#if     ((31 >= GSL_INCLUDER_FIRST_CASE) && (31 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (31))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 31),
+#endif
+#endif
+#if     ((32 >= GSL_INCLUDER_FIRST_CASE) && (32 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (32))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 32),
+#endif
+#endif
+#if     ((33 >= GSL_INCLUDER_FIRST_CASE) && (33 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (33))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 33),
+#endif
+#endif
+#if     ((34 >= GSL_INCLUDER_FIRST_CASE) && (34 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (34))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 34),
+#endif
+#endif
+#if     ((35 >= GSL_INCLUDER_FIRST_CASE) && (35 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (35))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 35),
+#endif
+#endif
+#if     ((36 >= GSL_INCLUDER_FIRST_CASE) && (36 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (36))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 36),
+#endif
+#endif
+#if     ((37 >= GSL_INCLUDER_FIRST_CASE) && (37 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (37))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 37),
+#endif
+#endif
+#if     ((38 >= GSL_INCLUDER_FIRST_CASE) && (38 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (38))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 38),
+#endif
+#endif
+#if     ((39 >= GSL_INCLUDER_FIRST_CASE) && (39 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (39))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 39),
+#endif
+#endif
+#if     ((40 >= GSL_INCLUDER_FIRST_CASE) && (40 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (40))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 40),
+#endif
+#endif
+#if     ((41 >= GSL_INCLUDER_FIRST_CASE) && (41 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (41))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 41),
+#endif
+#endif
+#if     ((42 >= GSL_INCLUDER_FIRST_CASE) && (42 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (42))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 42),
+#endif
+#endif
+#if     ((43 >= GSL_INCLUDER_FIRST_CASE) && (43 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (43))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 43),
+#endif
+#endif
+#if     ((44 >= GSL_INCLUDER_FIRST_CASE) && (44 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (44))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 44),
+#endif
+#endif
+#if     ((45 >= GSL_INCLUDER_FIRST_CASE) && (45 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (45))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 45),
+#endif
+#endif
+#if     ((46 >= GSL_INCLUDER_FIRST_CASE) && (46 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (46))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 46),
+#endif
+#endif
+#if     ((47 >= GSL_INCLUDER_FIRST_CASE) && (47 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (47))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 47),
+#endif
+#endif
+#if     ((48 >= GSL_INCLUDER_FIRST_CASE) && (48 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (48))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 48),
+#endif
+#endif
+#if     ((49 >= GSL_INCLUDER_FIRST_CASE) && (49 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (49))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 49),
+#endif
+#endif
+#if     ((50 >= GSL_INCLUDER_FIRST_CASE) && (50 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (50))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 50),
+#endif
+#endif
+#if     ((51 >= GSL_INCLUDER_FIRST_CASE) && (51 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (51))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 51),
+#endif
+#endif
+#if     ((52 >= GSL_INCLUDER_FIRST_CASE) && (52 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (52))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 52),
+#endif
+#endif
+#if     ((53 >= GSL_INCLUDER_FIRST_CASE) && (53 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (53))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 53),
+#endif
+#endif
+#if     ((54 >= GSL_INCLUDER_FIRST_CASE) && (54 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (54))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 54),
+#endif
+#endif
+#if     ((55 >= GSL_INCLUDER_FIRST_CASE) && (55 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (55))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 55),
+#endif
+#endif
+#if     ((56 >= GSL_INCLUDER_FIRST_CASE) && (56 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (56))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 56),
+#endif
+#endif
+#if     ((57 >= GSL_INCLUDER_FIRST_CASE) && (57 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (57))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 57),
+#endif
+#endif
+#if     ((58 >= GSL_INCLUDER_FIRST_CASE) && (58 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (58))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 58),
+#endif
+#endif
+#if     ((59 >= GSL_INCLUDER_FIRST_CASE) && (59 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (59))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 59),
+#endif
+#endif
+#if     ((60 >= GSL_INCLUDER_FIRST_CASE) && (60 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (60))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 60),
+#endif
+#endif
+#if     ((61 >= GSL_INCLUDER_FIRST_CASE) && (61 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (61))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 61),
+#endif
+#endif
+#if     ((62 >= GSL_INCLUDER_FIRST_CASE) && (62 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (62))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 62),
+#endif
+#endif
+#if     ((63 >= GSL_INCLUDER_FIRST_CASE) && (63 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (63))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 63),
+#endif
+#endif
+#if     ((64 >= GSL_INCLUDER_FIRST_CASE) && (64 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (64))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 64),
+#endif
+#endif
+#if     ((65 >= GSL_INCLUDER_FIRST_CASE) && (65 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (65))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 65),
+#endif
+#endif
+#if     ((66 >= GSL_INCLUDER_FIRST_CASE) && (66 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (66))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 66),
+#endif
+#endif
+#if     ((67 >= GSL_INCLUDER_FIRST_CASE) && (67 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (67))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 67),
+#endif
+#endif
+#if     ((68 >= GSL_INCLUDER_FIRST_CASE) && (68 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (68))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 68),
+#endif
+#endif
+#if     ((69 >= GSL_INCLUDER_FIRST_CASE) && (69 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (69))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 69),
+#endif
+#endif
+#if     ((70 >= GSL_INCLUDER_FIRST_CASE) && (70 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (70))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 70),
+#endif
+#endif
+#if     ((71 >= GSL_INCLUDER_FIRST_CASE) && (71 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (71))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 71),
+#endif
+#endif
+#if     ((72 >= GSL_INCLUDER_FIRST_CASE) && (72 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (72))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 72),
+#endif
+#endif
+#if     ((73 >= GSL_INCLUDER_FIRST_CASE) && (73 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (73))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 73),
+#endif
+#endif
+#if     ((74 >= GSL_INCLUDER_FIRST_CASE) && (74 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (74))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 74),
+#endif
+#endif
+#if     ((75 >= GSL_INCLUDER_FIRST_CASE) && (75 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (75))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 75),
+#endif
+#endif
+#if     ((76 >= GSL_INCLUDER_FIRST_CASE) && (76 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (76))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 76),
+#endif
+#endif
+#if     ((77 >= GSL_INCLUDER_FIRST_CASE) && (77 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (77))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 77),
+#endif
+#endif
+#if     ((78 >= GSL_INCLUDER_FIRST_CASE) && (78 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (78))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 78),
+#endif
+#endif
+#if     ((79 >= GSL_INCLUDER_FIRST_CASE) && (79 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (79))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 79),
+#endif
+#endif
+#if     ((80 >= GSL_INCLUDER_FIRST_CASE) && (80 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (80))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 80),
+#endif
+#endif
+#if     ((81 >= GSL_INCLUDER_FIRST_CASE) && (81 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (81))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 81),
+#endif
+#endif
+#if     ((82 >= GSL_INCLUDER_FIRST_CASE) && (82 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (82))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 82),
+#endif
+#endif
+#if     ((83 >= GSL_INCLUDER_FIRST_CASE) && (83 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (83))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 83),
+#endif
+#endif
+#if     ((84 >= GSL_INCLUDER_FIRST_CASE) && (84 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (84))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 84),
+#endif
+#endif
+#if     ((85 >= GSL_INCLUDER_FIRST_CASE) && (85 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (85))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 85),
+#endif
+#endif
+#if     ((86 >= GSL_INCLUDER_FIRST_CASE) && (86 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (86))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 86),
+#endif
+#endif
+#if     ((87 >= GSL_INCLUDER_FIRST_CASE) && (87 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (87))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 87),
+#endif
+#endif
+#if     ((88 >= GSL_INCLUDER_FIRST_CASE) && (88 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (88))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 88),
+#endif
+#endif
+#if     ((89 >= GSL_INCLUDER_FIRST_CASE) && (89 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (89))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 89),
+#endif
+#endif
+#if     ((90 >= GSL_INCLUDER_FIRST_CASE) && (90 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (90))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 90),
+#endif
+#endif
+#if     ((91 >= GSL_INCLUDER_FIRST_CASE) && (91 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (91))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 91),
+#endif
+#endif
+#if     ((92 >= GSL_INCLUDER_FIRST_CASE) && (92 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (92))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 92),
+#endif
+#endif
+#if     ((93 >= GSL_INCLUDER_FIRST_CASE) && (93 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (93))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 93),
+#endif
+#endif
+#if     ((94 >= GSL_INCLUDER_FIRST_CASE) && (94 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (94))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 94),
+#endif
+#endif
+#if     ((95 >= GSL_INCLUDER_FIRST_CASE) && (95 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (95))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 95),
+#endif
+#endif
+#if     ((96 >= GSL_INCLUDER_FIRST_CASE) && (96 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (96))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 96),
+#endif
+#endif
+#if     ((97 >= GSL_INCLUDER_FIRST_CASE) && (97 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (97))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 97),
+#endif
+#endif
+#if     ((98 >= GSL_INCLUDER_FIRST_CASE) && (98 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (98))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 98),
+#endif
+#endif
+#if     ((99 >= GSL_INCLUDER_FIRST_CASE) && (99 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (99))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 99),
+#endif
+#endif
+#if     ((100 >= GSL_INCLUDER_FIRST_CASE) && (100 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (100))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 100),
+#endif
+#endif
+#if     ((101 >= GSL_INCLUDER_FIRST_CASE) && (101 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (101))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 101),
+#endif
+#endif
+#if     ((102 >= GSL_INCLUDER_FIRST_CASE) && (102 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (102))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 102),
+#endif
+#endif
+#if     ((103 >= GSL_INCLUDER_FIRST_CASE) && (103 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (103))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 103),
+#endif
+#endif
+#if     ((104 >= GSL_INCLUDER_FIRST_CASE) && (104 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (104))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 104),
+#endif
+#endif
+#if     ((105 >= GSL_INCLUDER_FIRST_CASE) && (105 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (105))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 105),
+#endif
+#endif
+#if     ((106 >= GSL_INCLUDER_FIRST_CASE) && (106 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (106))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 106),
+#endif
+#endif
+#if     ((107 >= GSL_INCLUDER_FIRST_CASE) && (107 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (107))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 107),
+#endif
+#endif
+#if     ((108 >= GSL_INCLUDER_FIRST_CASE) && (108 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (108))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 108),
+#endif
+#endif
+#if     ((109 >= GSL_INCLUDER_FIRST_CASE) && (109 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (109))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 109),
+#endif
+#endif
+#if     ((110 >= GSL_INCLUDER_FIRST_CASE) && (110 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (110))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 110),
+#endif
+#endif
+#if     ((111 >= GSL_INCLUDER_FIRST_CASE) && (111 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (111))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 111),
+#endif
+#endif
+#if     ((112 >= GSL_INCLUDER_FIRST_CASE) && (112 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (112))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 112),
+#endif
+#endif
+#if     ((113 >= GSL_INCLUDER_FIRST_CASE) && (113 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (113))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 113),
+#endif
+#endif
+#if     ((114 >= GSL_INCLUDER_FIRST_CASE) && (114 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (114))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 114),
+#endif
+#endif
+#if     ((115 >= GSL_INCLUDER_FIRST_CASE) && (115 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (115))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 115),
+#endif
+#endif
+#if     ((116 >= GSL_INCLUDER_FIRST_CASE) && (116 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (116))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 116),
+#endif
+#endif
+#if     ((117 >= GSL_INCLUDER_FIRST_CASE) && (117 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (117))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 117),
+#endif
+#endif
+#if     ((118 >= GSL_INCLUDER_FIRST_CASE) && (118 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (118))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 118),
+#endif
+#endif
+#if     ((119 >= GSL_INCLUDER_FIRST_CASE) && (119 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (119))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 119),
+#endif
+#endif
+#if     ((120 >= GSL_INCLUDER_FIRST_CASE) && (120 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (120))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 120),
+#endif
+#endif
+#if     ((121 >= GSL_INCLUDER_FIRST_CASE) && (121 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (121))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 121),
+#endif
+#endif
+#if     ((122 >= GSL_INCLUDER_FIRST_CASE) && (122 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (122))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 122),
+#endif
+#endif
+#if     ((123 >= GSL_INCLUDER_FIRST_CASE) && (123 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (123))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 123),
+#endif
+#endif
+#if     ((124 >= GSL_INCLUDER_FIRST_CASE) && (124 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (124))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 124),
+#endif
+#endif
+#if     ((125 >= GSL_INCLUDER_FIRST_CASE) && (125 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (125))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 125),
+#endif
+#endif
+#if     ((126 >= GSL_INCLUDER_FIRST_CASE) && (126 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (126))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 126),
+#endif
+#endif
+#if     ((127 >= GSL_INCLUDER_FIRST_CASE) && (127 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (127))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 127),
+#endif
+#endif
+#if     ((128 >= GSL_INCLUDER_FIRST_CASE) && (128 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (128))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 128),
+#endif
+#endif
+#if     ((129 >= GSL_INCLUDER_FIRST_CASE) && (129 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (129))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 129),
+#endif
+#endif
+#if     ((130 >= GSL_INCLUDER_FIRST_CASE) && (130 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (130))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 130),
+#endif
+#endif
+#if     ((131 >= GSL_INCLUDER_FIRST_CASE) && (131 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (131))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 131),
+#endif
+#endif
+#if     ((132 >= GSL_INCLUDER_FIRST_CASE) && (132 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (132))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 132),
+#endif
+#endif
+#if     ((133 >= GSL_INCLUDER_FIRST_CASE) && (133 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (133))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 133),
+#endif
+#endif
+#if     ((134 >= GSL_INCLUDER_FIRST_CASE) && (134 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (134))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 134),
+#endif
+#endif
+#if     ((135 >= GSL_INCLUDER_FIRST_CASE) && (135 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (135))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 135),
+#endif
+#endif
+#if     ((136 >= GSL_INCLUDER_FIRST_CASE) && (136 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (136))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 136),
+#endif
+#endif
+#if     ((137 >= GSL_INCLUDER_FIRST_CASE) && (137 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (137))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 137),
+#endif
+#endif
+#if     ((138 >= GSL_INCLUDER_FIRST_CASE) && (138 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (138))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 138),
+#endif
+#endif
+#if     ((139 >= GSL_INCLUDER_FIRST_CASE) && (139 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (139))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 139),
+#endif
+#endif
+#if     ((140 >= GSL_INCLUDER_FIRST_CASE) && (140 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (140))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 140),
+#endif
+#endif
+#if     ((141 >= GSL_INCLUDER_FIRST_CASE) && (141 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (141))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 141),
+#endif
+#endif
+#if     ((142 >= GSL_INCLUDER_FIRST_CASE) && (142 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (142))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 142),
+#endif
+#endif
+#if     ((143 >= GSL_INCLUDER_FIRST_CASE) && (143 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (143))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 143),
+#endif
+#endif
+#if     ((144 >= GSL_INCLUDER_FIRST_CASE) && (144 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (144))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 144),
+#endif
+#endif
+#if     ((145 >= GSL_INCLUDER_FIRST_CASE) && (145 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (145))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 145),
+#endif
+#endif
+#if     ((146 >= GSL_INCLUDER_FIRST_CASE) && (146 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (146))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 146),
+#endif
+#endif
+#if     ((147 >= GSL_INCLUDER_FIRST_CASE) && (147 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (147))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 147),
+#endif
+#endif
+#if     ((148 >= GSL_INCLUDER_FIRST_CASE) && (148 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (148))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 148),
+#endif
+#endif
+#if     ((149 >= GSL_INCLUDER_FIRST_CASE) && (149 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (149))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 149),
+#endif
+#endif
+#if     ((150 >= GSL_INCLUDER_FIRST_CASE) && (150 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (150))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 150),
+#endif
+#endif
+#if     ((151 >= GSL_INCLUDER_FIRST_CASE) && (151 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (151))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 151),
+#endif
+#endif
+#if     ((152 >= GSL_INCLUDER_FIRST_CASE) && (152 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (152))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 152),
+#endif
+#endif
+#if     ((153 >= GSL_INCLUDER_FIRST_CASE) && (153 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (153))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 153),
+#endif
+#endif
+#if     ((154 >= GSL_INCLUDER_FIRST_CASE) && (154 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (154))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 154),
+#endif
+#endif
+#if     ((155 >= GSL_INCLUDER_FIRST_CASE) && (155 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (155))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 155),
+#endif
+#endif
+#if     ((156 >= GSL_INCLUDER_FIRST_CASE) && (156 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (156))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 156),
+#endif
+#endif
+#if     ((157 >= GSL_INCLUDER_FIRST_CASE) && (157 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (157))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 157),
+#endif
+#endif
+#if     ((158 >= GSL_INCLUDER_FIRST_CASE) && (158 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (158))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 158),
+#endif
+#endif
+#if     ((159 >= GSL_INCLUDER_FIRST_CASE) && (159 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (159))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 159),
+#endif
+#endif
+#if     ((160 >= GSL_INCLUDER_FIRST_CASE) && (160 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (160))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 160),
+#endif
+#endif
+#if     ((161 >= GSL_INCLUDER_FIRST_CASE) && (161 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (161))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 161),
+#endif
+#endif
+#if     ((162 >= GSL_INCLUDER_FIRST_CASE) && (162 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (162))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 162),
+#endif
+#endif
+#if     ((163 >= GSL_INCLUDER_FIRST_CASE) && (163 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (163))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 163),
+#endif
+#endif
+#if     ((164 >= GSL_INCLUDER_FIRST_CASE) && (164 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (164))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 164),
+#endif
+#endif
+#if     ((165 >= GSL_INCLUDER_FIRST_CASE) && (165 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (165))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 165),
+#endif
+#endif
+#if     ((166 >= GSL_INCLUDER_FIRST_CASE) && (166 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (166))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 166),
+#endif
+#endif
+#if     ((167 >= GSL_INCLUDER_FIRST_CASE) && (167 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (167))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 167),
+#endif
+#endif
+#if     ((168 >= GSL_INCLUDER_FIRST_CASE) && (168 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (168))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 168),
+#endif
+#endif
+#if     ((169 >= GSL_INCLUDER_FIRST_CASE) && (169 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (169))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 169),
+#endif
+#endif
+#if     ((170 >= GSL_INCLUDER_FIRST_CASE) && (170 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (170))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 170),
+#endif
+#endif
+#if     ((171 >= GSL_INCLUDER_FIRST_CASE) && (171 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (171))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 171),
+#endif
+#endif
+#if     ((172 >= GSL_INCLUDER_FIRST_CASE) && (172 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (172))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 172),
+#endif
+#endif
+#if     ((173 >= GSL_INCLUDER_FIRST_CASE) && (173 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (173))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 173),
+#endif
+#endif
+#if     ((174 >= GSL_INCLUDER_FIRST_CASE) && (174 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (174))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 174),
+#endif
+#endif
+#if     ((175 >= GSL_INCLUDER_FIRST_CASE) && (175 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (175))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 175),
+#endif
+#endif
+#if     ((176 >= GSL_INCLUDER_FIRST_CASE) && (176 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (176))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 176),
+#endif
+#endif
+#if     ((177 >= GSL_INCLUDER_FIRST_CASE) && (177 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (177))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 177),
+#endif
+#endif
+#if     ((178 >= GSL_INCLUDER_FIRST_CASE) && (178 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (178))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 178),
+#endif
+#endif
+#if     ((179 >= GSL_INCLUDER_FIRST_CASE) && (179 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (179))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 179),
+#endif
+#endif
+#if     ((180 >= GSL_INCLUDER_FIRST_CASE) && (180 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (180))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 180),
+#endif
+#endif
+#if     ((181 >= GSL_INCLUDER_FIRST_CASE) && (181 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (181))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 181),
+#endif
+#endif
+#if     ((182 >= GSL_INCLUDER_FIRST_CASE) && (182 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (182))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 182),
+#endif
+#endif
+#if     ((183 >= GSL_INCLUDER_FIRST_CASE) && (183 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (183))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 183),
+#endif
+#endif
+#if     ((184 >= GSL_INCLUDER_FIRST_CASE) && (184 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (184))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 184),
+#endif
+#endif
+#if     ((185 >= GSL_INCLUDER_FIRST_CASE) && (185 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (185))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 185),
+#endif
+#endif
+#if     ((186 >= GSL_INCLUDER_FIRST_CASE) && (186 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (186))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 186),
+#endif
+#endif
+#if     ((187 >= GSL_INCLUDER_FIRST_CASE) && (187 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (187))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 187),
+#endif
+#endif
+#if     ((188 >= GSL_INCLUDER_FIRST_CASE) && (188 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (188))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 188),
+#endif
+#endif
+#if     ((189 >= GSL_INCLUDER_FIRST_CASE) && (189 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (189))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 189),
+#endif
+#endif
+#if     ((190 >= GSL_INCLUDER_FIRST_CASE) && (190 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (190))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 190),
+#endif
+#endif
+#if     ((191 >= GSL_INCLUDER_FIRST_CASE) && (191 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (191))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 191),
+#endif
+#endif
+#if     ((192 >= GSL_INCLUDER_FIRST_CASE) && (192 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (192))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 192),
+#endif
+#endif
+#if     ((193 >= GSL_INCLUDER_FIRST_CASE) && (193 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (193))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 193),
+#endif
+#endif
+#if     ((194 >= GSL_INCLUDER_FIRST_CASE) && (194 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (194))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 194),
+#endif
+#endif
+#if     ((195 >= GSL_INCLUDER_FIRST_CASE) && (195 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (195))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 195),
+#endif
+#endif
+#if     ((196 >= GSL_INCLUDER_FIRST_CASE) && (196 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (196))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 196),
+#endif
+#endif
+#if     ((197 >= GSL_INCLUDER_FIRST_CASE) && (197 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (197))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 197),
+#endif
+#endif
+#if     ((198 >= GSL_INCLUDER_FIRST_CASE) && (198 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (198))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 198),
+#endif
+#endif
+#if     ((199 >= GSL_INCLUDER_FIRST_CASE) && (199 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (199))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 199),
+#endif
+#endif
+#if     ((200 >= GSL_INCLUDER_FIRST_CASE) && (200 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (200))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 200),
+#endif
+#endif
+#if     ((201 >= GSL_INCLUDER_FIRST_CASE) && (201 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (201))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 201),
+#endif
+#endif
+#if     ((202 >= GSL_INCLUDER_FIRST_CASE) && (202 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (202))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 202),
+#endif
+#endif
+#if     ((203 >= GSL_INCLUDER_FIRST_CASE) && (203 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (203))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 203),
+#endif
+#endif
+#if     ((204 >= GSL_INCLUDER_FIRST_CASE) && (204 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (204))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 204),
+#endif
+#endif
+#if     ((205 >= GSL_INCLUDER_FIRST_CASE) && (205 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (205))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 205),
+#endif
+#endif
+#if     ((206 >= GSL_INCLUDER_FIRST_CASE) && (206 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (206))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 206),
+#endif
+#endif
+#if     ((207 >= GSL_INCLUDER_FIRST_CASE) && (207 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (207))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 207),
+#endif
+#endif
+#if     ((208 >= GSL_INCLUDER_FIRST_CASE) && (208 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (208))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 208),
+#endif
+#endif
+#if     ((209 >= GSL_INCLUDER_FIRST_CASE) && (209 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (209))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 209),
+#endif
+#endif
+#if     ((210 >= GSL_INCLUDER_FIRST_CASE) && (210 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (210))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 210),
+#endif
+#endif
+#if     ((211 >= GSL_INCLUDER_FIRST_CASE) && (211 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (211))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 211),
+#endif
+#endif
+#if     ((212 >= GSL_INCLUDER_FIRST_CASE) && (212 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (212))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 212),
+#endif
+#endif
+#if     ((213 >= GSL_INCLUDER_FIRST_CASE) && (213 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (213))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 213),
+#endif
+#endif
+#if     ((214 >= GSL_INCLUDER_FIRST_CASE) && (214 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (214))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 214),
+#endif
+#endif
+#if     ((215 >= GSL_INCLUDER_FIRST_CASE) && (215 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (215))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 215),
+#endif
+#endif
+#if     ((216 >= GSL_INCLUDER_FIRST_CASE) && (216 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (216))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 216),
+#endif
+#endif
+#if     ((217 >= GSL_INCLUDER_FIRST_CASE) && (217 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (217))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 217),
+#endif
+#endif
+#if     ((218 >= GSL_INCLUDER_FIRST_CASE) && (218 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (218))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 218),
+#endif
+#endif
+#if     ((219 >= GSL_INCLUDER_FIRST_CASE) && (219 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (219))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 219),
+#endif
+#endif
+#if     ((220 >= GSL_INCLUDER_FIRST_CASE) && (220 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (220))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 220),
+#endif
+#endif
+#if     ((221 >= GSL_INCLUDER_FIRST_CASE) && (221 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (221))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 221),
+#endif
+#endif
+#if     ((222 >= GSL_INCLUDER_FIRST_CASE) && (222 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (222))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 222),
+#endif
+#endif
+#if     ((223 >= GSL_INCLUDER_FIRST_CASE) && (223 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (223))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 223),
+#endif
+#endif
+#if     ((224 >= GSL_INCLUDER_FIRST_CASE) && (224 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (224))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 224),
+#endif
+#endif
+#if     ((225 >= GSL_INCLUDER_FIRST_CASE) && (225 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (225))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 225),
+#endif
+#endif
+#if     ((226 >= GSL_INCLUDER_FIRST_CASE) && (226 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (226))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 226),
+#endif
+#endif
+#if     ((227 >= GSL_INCLUDER_FIRST_CASE) && (227 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (227))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 227),
+#endif
+#endif
+#if     ((228 >= GSL_INCLUDER_FIRST_CASE) && (228 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (228))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 228),
+#endif
+#endif
+#if     ((229 >= GSL_INCLUDER_FIRST_CASE) && (229 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (229))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 229),
+#endif
+#endif
+#if     ((230 >= GSL_INCLUDER_FIRST_CASE) && (230 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (230))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 230),
+#endif
+#endif
+#if     ((231 >= GSL_INCLUDER_FIRST_CASE) && (231 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (231))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 231),
+#endif
+#endif
+#if     ((232 >= GSL_INCLUDER_FIRST_CASE) && (232 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (232))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 232),
+#endif
+#endif
+#if     ((233 >= GSL_INCLUDER_FIRST_CASE) && (233 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (233))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 233),
+#endif
+#endif
+#if     ((234 >= GSL_INCLUDER_FIRST_CASE) && (234 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (234))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 234),
+#endif
+#endif
+#if     ((235 >= GSL_INCLUDER_FIRST_CASE) && (235 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (235))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 235),
+#endif
+#endif
+#if     ((236 >= GSL_INCLUDER_FIRST_CASE) && (236 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (236))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 236),
+#endif
+#endif
+#if     ((237 >= GSL_INCLUDER_FIRST_CASE) && (237 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (237))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 237),
+#endif
+#endif
+#if     ((238 >= GSL_INCLUDER_FIRST_CASE) && (238 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (238))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 238),
+#endif
+#endif
+#if     ((239 >= GSL_INCLUDER_FIRST_CASE) && (239 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (239))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 239),
+#endif
+#endif
+#if     ((240 >= GSL_INCLUDER_FIRST_CASE) && (240 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (240))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 240),
+#endif
+#endif
+#if     ((241 >= GSL_INCLUDER_FIRST_CASE) && (241 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (241))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 241),
+#endif
+#endif
+#if     ((242 >= GSL_INCLUDER_FIRST_CASE) && (242 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (242))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 242),
+#endif
+#endif
+#if     ((243 >= GSL_INCLUDER_FIRST_CASE) && (243 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (243))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 243),
+#endif
+#endif
+#if     ((244 >= GSL_INCLUDER_FIRST_CASE) && (244 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (244))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 244),
+#endif
+#endif
+#if     ((245 >= GSL_INCLUDER_FIRST_CASE) && (245 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (245))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 245),
+#endif
+#endif
+#if     ((246 >= GSL_INCLUDER_FIRST_CASE) && (246 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (246))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 246),
+#endif
+#endif
+#if     ((247 >= GSL_INCLUDER_FIRST_CASE) && (247 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (247))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 247),
+#endif
+#endif
+#if     ((248 >= GSL_INCLUDER_FIRST_CASE) && (248 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (248))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 248),
+#endif
+#endif
+#if     ((249 >= GSL_INCLUDER_FIRST_CASE) && (249 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (249))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 249),
+#endif
+#endif
+#if     ((250 >= GSL_INCLUDER_FIRST_CASE) && (250 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (250))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 250),
+#endif
+#endif
+#if     ((251 >= GSL_INCLUDER_FIRST_CASE) && (251 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (251))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 251),
+#endif
+#endif
+#if     ((252 >= GSL_INCLUDER_FIRST_CASE) && (252 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (252))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 252),
+#endif
+#endif
+#if     ((253 >= GSL_INCLUDER_FIRST_CASE) && (253 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (253))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 253),
+#endif
+#endif
+#if     ((254 >= GSL_INCLUDER_FIRST_CASE) && (254 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (254))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 254),
+#endif
+#endif
+#if     ((255 >= GSL_INCLUDER_FIRST_CASE) && (255 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (255))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 255),
+#endif
+#endif
+#if     ((256 >= GSL_INCLUDER_FIRST_CASE) && (256 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (256))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 256),
+#endif
+#endif
+#if     ((257 >= GSL_INCLUDER_FIRST_CASE) && (257 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (257))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 257),
+#endif
+#endif
+#if     ((258 >= GSL_INCLUDER_FIRST_CASE) && (258 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (258))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 258),
+#endif
+#endif
+#if     ((259 >= GSL_INCLUDER_FIRST_CASE) && (259 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (259))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 259),
+#endif
+#endif
+#if     ((260 >= GSL_INCLUDER_FIRST_CASE) && (260 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (260))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 260),
+#endif
+#endif
+#if     ((261 >= GSL_INCLUDER_FIRST_CASE) && (261 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (261))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 261),
+#endif
+#endif
+#if     ((262 >= GSL_INCLUDER_FIRST_CASE) && (262 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (262))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 262),
+#endif
+#endif
+#if     ((263 >= GSL_INCLUDER_FIRST_CASE) && (263 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (263))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 263),
+#endif
+#endif
+#if     ((264 >= GSL_INCLUDER_FIRST_CASE) && (264 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (264))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 264),
+#endif
+#endif
+#if     ((265 >= GSL_INCLUDER_FIRST_CASE) && (265 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (265))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 265),
+#endif
+#endif
+#if     ((266 >= GSL_INCLUDER_FIRST_CASE) && (266 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (266))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 266),
+#endif
+#endif
+#if     ((267 >= GSL_INCLUDER_FIRST_CASE) && (267 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (267))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 267),
+#endif
+#endif
+#if     ((268 >= GSL_INCLUDER_FIRST_CASE) && (268 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (268))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 268),
+#endif
+#endif
+#if     ((269 >= GSL_INCLUDER_FIRST_CASE) && (269 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (269))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 269),
+#endif
+#endif
+#if     ((270 >= GSL_INCLUDER_FIRST_CASE) && (270 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (270))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 270),
+#endif
+#endif
+#if     ((271 >= GSL_INCLUDER_FIRST_CASE) && (271 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (271))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 271),
+#endif
+#endif
+#if     ((272 >= GSL_INCLUDER_FIRST_CASE) && (272 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (272))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 272),
+#endif
+#endif
+#if     ((273 >= GSL_INCLUDER_FIRST_CASE) && (273 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (273))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 273),
+#endif
+#endif
+#if     ((274 >= GSL_INCLUDER_FIRST_CASE) && (274 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (274))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 274),
+#endif
+#endif
+#if     ((275 >= GSL_INCLUDER_FIRST_CASE) && (275 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (275))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 275),
+#endif
+#endif
+#if     ((276 >= GSL_INCLUDER_FIRST_CASE) && (276 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (276))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 276),
+#endif
+#endif
+#if     ((277 >= GSL_INCLUDER_FIRST_CASE) && (277 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (277))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 277),
+#endif
+#endif
+#if     ((278 >= GSL_INCLUDER_FIRST_CASE) && (278 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (278))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 278),
+#endif
+#endif
+#if     ((279 >= GSL_INCLUDER_FIRST_CASE) && (279 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (279))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 279),
+#endif
+#endif
+#if     ((280 >= GSL_INCLUDER_FIRST_CASE) && (280 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (280))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 280),
+#endif
+#endif
+#if     ((281 >= GSL_INCLUDER_FIRST_CASE) && (281 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (281))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 281),
+#endif
+#endif
+#if     ((282 >= GSL_INCLUDER_FIRST_CASE) && (282 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (282))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 282),
+#endif
+#endif
+#if     ((283 >= GSL_INCLUDER_FIRST_CASE) && (283 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (283))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 283),
+#endif
+#endif
+#if     ((284 >= GSL_INCLUDER_FIRST_CASE) && (284 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (284))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 284),
+#endif
+#endif
+#if     ((285 >= GSL_INCLUDER_FIRST_CASE) && (285 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (285))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 285),
+#endif
+#endif
+#if     ((286 >= GSL_INCLUDER_FIRST_CASE) && (286 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (286))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 286),
+#endif
+#endif
+#if     ((287 >= GSL_INCLUDER_FIRST_CASE) && (287 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (287))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 287),
+#endif
+#endif
+#if     ((288 >= GSL_INCLUDER_FIRST_CASE) && (288 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (288))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 288),
+#endif
+#endif
+#if     ((289 >= GSL_INCLUDER_FIRST_CASE) && (289 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (289))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 289),
+#endif
+#endif
+#if     ((290 >= GSL_INCLUDER_FIRST_CASE) && (290 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (290))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 290),
+#endif
+#endif
+#if     ((291 >= GSL_INCLUDER_FIRST_CASE) && (291 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (291))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 291),
+#endif
+#endif
+#if     ((292 >= GSL_INCLUDER_FIRST_CASE) && (292 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (292))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 292),
+#endif
+#endif
+#if     ((293 >= GSL_INCLUDER_FIRST_CASE) && (293 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (293))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 293),
+#endif
+#endif
+#if     ((294 >= GSL_INCLUDER_FIRST_CASE) && (294 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (294))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 294),
+#endif
+#endif
+#if     ((295 >= GSL_INCLUDER_FIRST_CASE) && (295 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (295))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 295),
+#endif
+#endif
+#if     ((296 >= GSL_INCLUDER_FIRST_CASE) && (296 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (296))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 296),
+#endif
+#endif
+#if     ((297 >= GSL_INCLUDER_FIRST_CASE) && (297 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (297))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 297),
+#endif
+#endif
+#if     ((298 >= GSL_INCLUDER_FIRST_CASE) && (298 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (298))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 298),
+#endif
+#endif
+#if     ((299 >= GSL_INCLUDER_FIRST_CASE) && (299 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (299))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 299),
+#endif
+#endif
+#if     ((300 >= GSL_INCLUDER_FIRST_CASE) && (300 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (300))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 300),
+#endif
+#endif
+#if     ((301 >= GSL_INCLUDER_FIRST_CASE) && (301 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (301))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 301),
+#endif
+#endif
+#if     ((302 >= GSL_INCLUDER_FIRST_CASE) && (302 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (302))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 302),
+#endif
+#endif
+#if     ((303 >= GSL_INCLUDER_FIRST_CASE) && (303 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (303))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 303),
+#endif
+#endif
+#if     ((304 >= GSL_INCLUDER_FIRST_CASE) && (304 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (304))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 304),
+#endif
+#endif
+#if     ((305 >= GSL_INCLUDER_FIRST_CASE) && (305 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (305))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 305),
+#endif
+#endif
+#if     ((306 >= GSL_INCLUDER_FIRST_CASE) && (306 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (306))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 306),
+#endif
+#endif
+#if     ((307 >= GSL_INCLUDER_FIRST_CASE) && (307 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (307))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 307),
+#endif
+#endif
+#if     ((308 >= GSL_INCLUDER_FIRST_CASE) && (308 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (308))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 308),
+#endif
+#endif
+#if     ((309 >= GSL_INCLUDER_FIRST_CASE) && (309 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (309))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 309),
+#endif
+#endif
+#if     ((310 >= GSL_INCLUDER_FIRST_CASE) && (310 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (310))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 310),
+#endif
+#endif
+#if     ((311 >= GSL_INCLUDER_FIRST_CASE) && (311 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (311))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 311),
+#endif
+#endif
+#if     ((312 >= GSL_INCLUDER_FIRST_CASE) && (312 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (312))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 312),
+#endif
+#endif
+#if     ((313 >= GSL_INCLUDER_FIRST_CASE) && (313 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (313))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 313),
+#endif
+#endif
+#if     ((314 >= GSL_INCLUDER_FIRST_CASE) && (314 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (314))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 314),
+#endif
+#endif
+#if     ((315 >= GSL_INCLUDER_FIRST_CASE) && (315 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (315))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 315),
+#endif
+#endif
+#if     ((316 >= GSL_INCLUDER_FIRST_CASE) && (316 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (316))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 316),
+#endif
+#endif
+#if     ((317 >= GSL_INCLUDER_FIRST_CASE) && (317 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (317))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 317),
+#endif
+#endif
+#if     ((318 >= GSL_INCLUDER_FIRST_CASE) && (318 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (318))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 318),
+#endif
+#endif
+#if     ((319 >= GSL_INCLUDER_FIRST_CASE) && (319 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (319))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 319),
+#endif
+#endif
+#if     ((320 >= GSL_INCLUDER_FIRST_CASE) && (320 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (320))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 320),
+#endif
+#endif
+#if     ((321 >= GSL_INCLUDER_FIRST_CASE) && (321 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (321))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 321),
+#endif
+#endif
+#if     ((322 >= GSL_INCLUDER_FIRST_CASE) && (322 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (322))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 322),
+#endif
+#endif
+#if     ((323 >= GSL_INCLUDER_FIRST_CASE) && (323 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (323))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 323),
+#endif
+#endif
+#if     ((324 >= GSL_INCLUDER_FIRST_CASE) && (324 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (324))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 324),
+#endif
+#endif
+#if     ((325 >= GSL_INCLUDER_FIRST_CASE) && (325 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (325))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 325),
+#endif
+#endif
+#if     ((326 >= GSL_INCLUDER_FIRST_CASE) && (326 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (326))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 326),
+#endif
+#endif
+#if     ((327 >= GSL_INCLUDER_FIRST_CASE) && (327 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (327))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 327),
+#endif
+#endif
+#if     ((328 >= GSL_INCLUDER_FIRST_CASE) && (328 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (328))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 328),
+#endif
+#endif
+#if     ((329 >= GSL_INCLUDER_FIRST_CASE) && (329 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (329))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 329),
+#endif
+#endif
+#if     ((330 >= GSL_INCLUDER_FIRST_CASE) && (330 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (330))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 330),
+#endif
+#endif
+#if     ((331 >= GSL_INCLUDER_FIRST_CASE) && (331 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (331))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 331),
+#endif
+#endif
+#if     ((332 >= GSL_INCLUDER_FIRST_CASE) && (332 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (332))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 332),
+#endif
+#endif
+#if     ((333 >= GSL_INCLUDER_FIRST_CASE) && (333 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (333))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 333),
+#endif
+#endif
+#if     ((334 >= GSL_INCLUDER_FIRST_CASE) && (334 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (334))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 334),
+#endif
+#endif
+#if     ((335 >= GSL_INCLUDER_FIRST_CASE) && (335 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (335))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 335),
+#endif
+#endif
+#if     ((336 >= GSL_INCLUDER_FIRST_CASE) && (336 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (336))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 336),
+#endif
+#endif
+#if     ((337 >= GSL_INCLUDER_FIRST_CASE) && (337 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (337))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 337),
+#endif
+#endif
+#if     ((338 >= GSL_INCLUDER_FIRST_CASE) && (338 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (338))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 338),
+#endif
+#endif
+#if     ((339 >= GSL_INCLUDER_FIRST_CASE) && (339 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (339))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 339),
+#endif
+#endif
+#if     ((340 >= GSL_INCLUDER_FIRST_CASE) && (340 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (340))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 340),
+#endif
+#endif
+#if     ((341 >= GSL_INCLUDER_FIRST_CASE) && (341 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (341))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 341),
+#endif
+#endif
+#if     ((342 >= GSL_INCLUDER_FIRST_CASE) && (342 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (342))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 342),
+#endif
+#endif
+#if     ((343 >= GSL_INCLUDER_FIRST_CASE) && (343 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (343))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 343),
+#endif
+#endif
+#if     ((344 >= GSL_INCLUDER_FIRST_CASE) && (344 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (344))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 344),
+#endif
+#endif
+#if     ((345 >= GSL_INCLUDER_FIRST_CASE) && (345 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (345))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 345),
+#endif
+#endif
+#if     ((346 >= GSL_INCLUDER_FIRST_CASE) && (346 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (346))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 346),
+#endif
+#endif
+#if     ((347 >= GSL_INCLUDER_FIRST_CASE) && (347 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (347))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 347),
+#endif
+#endif
+#if     ((348 >= GSL_INCLUDER_FIRST_CASE) && (348 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (348))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 348),
+#endif
+#endif
+#if     ((349 >= GSL_INCLUDER_FIRST_CASE) && (349 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (349))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 349),
+#endif
+#endif
+#if     ((350 >= GSL_INCLUDER_FIRST_CASE) && (350 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (350))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 350),
+#endif
+#endif
+#if     ((351 >= GSL_INCLUDER_FIRST_CASE) && (351 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (351))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 351),
+#endif
+#endif
+#if     ((352 >= GSL_INCLUDER_FIRST_CASE) && (352 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (352))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 352),
+#endif
+#endif
+#if     ((353 >= GSL_INCLUDER_FIRST_CASE) && (353 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (353))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 353),
+#endif
+#endif
+#if     ((354 >= GSL_INCLUDER_FIRST_CASE) && (354 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (354))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 354),
+#endif
+#endif
+#if     ((355 >= GSL_INCLUDER_FIRST_CASE) && (355 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (355))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 355),
+#endif
+#endif
+#if     ((356 >= GSL_INCLUDER_FIRST_CASE) && (356 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (356))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 356),
+#endif
+#endif
+#if     ((357 >= GSL_INCLUDER_FIRST_CASE) && (357 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (357))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 357),
+#endif
+#endif
+#if     ((358 >= GSL_INCLUDER_FIRST_CASE) && (358 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (358))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 358),
+#endif
+#endif
+#if     ((359 >= GSL_INCLUDER_FIRST_CASE) && (359 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (359))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 359),
+#endif
+#endif
+#if     ((360 >= GSL_INCLUDER_FIRST_CASE) && (360 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (360))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 360),
+#endif
+#endif
+#if     ((361 >= GSL_INCLUDER_FIRST_CASE) && (361 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (361))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 361),
+#endif
+#endif
+#if     ((362 >= GSL_INCLUDER_FIRST_CASE) && (362 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (362))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 362),
+#endif
+#endif
+#if     ((363 >= GSL_INCLUDER_FIRST_CASE) && (363 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (363))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 363),
+#endif
+#endif
+#if     ((364 >= GSL_INCLUDER_FIRST_CASE) && (364 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (364))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 364),
+#endif
+#endif
+#if     ((365 >= GSL_INCLUDER_FIRST_CASE) && (365 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (365))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 365),
+#endif
+#endif
+#if     ((366 >= GSL_INCLUDER_FIRST_CASE) && (366 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (366))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 366),
+#endif
+#endif
+#if     ((367 >= GSL_INCLUDER_FIRST_CASE) && (367 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (367))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 367),
+#endif
+#endif
+#if     ((368 >= GSL_INCLUDER_FIRST_CASE) && (368 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (368))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 368),
+#endif
+#endif
+#if     ((369 >= GSL_INCLUDER_FIRST_CASE) && (369 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (369))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 369),
+#endif
+#endif
+#if     ((370 >= GSL_INCLUDER_FIRST_CASE) && (370 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (370))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 370),
+#endif
+#endif
+#if     ((371 >= GSL_INCLUDER_FIRST_CASE) && (371 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (371))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 371),
+#endif
+#endif
+#if     ((372 >= GSL_INCLUDER_FIRST_CASE) && (372 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (372))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 372),
+#endif
+#endif
+#if     ((373 >= GSL_INCLUDER_FIRST_CASE) && (373 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (373))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 373),
+#endif
+#endif
+#if     ((374 >= GSL_INCLUDER_FIRST_CASE) && (374 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (374))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 374),
+#endif
+#endif
+#if     ((375 >= GSL_INCLUDER_FIRST_CASE) && (375 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (375))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 375),
+#endif
+#endif
+#if     ((376 >= GSL_INCLUDER_FIRST_CASE) && (376 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (376))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 376),
+#endif
+#endif
+#if     ((377 >= GSL_INCLUDER_FIRST_CASE) && (377 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (377))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 377),
+#endif
+#endif
+#if     ((378 >= GSL_INCLUDER_FIRST_CASE) && (378 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (378))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 378),
+#endif
+#endif
+#if     ((379 >= GSL_INCLUDER_FIRST_CASE) && (379 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (379))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 379),
+#endif
+#endif
+#if     ((380 >= GSL_INCLUDER_FIRST_CASE) && (380 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (380))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 380),
+#endif
+#endif
+#if     ((381 >= GSL_INCLUDER_FIRST_CASE) && (381 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (381))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 381),
+#endif
+#endif
+#if     ((382 >= GSL_INCLUDER_FIRST_CASE) && (382 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (382))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 382),
+#endif
+#endif
+#if     ((383 >= GSL_INCLUDER_FIRST_CASE) && (383 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (383))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 383),
+#endif
+#endif
+#if     ((384 >= GSL_INCLUDER_FIRST_CASE) && (384 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (384))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 384),
+#endif
+#endif
+#if     ((385 >= GSL_INCLUDER_FIRST_CASE) && (385 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (385))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 385),
+#endif
+#endif
+#if     ((386 >= GSL_INCLUDER_FIRST_CASE) && (386 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (386))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 386),
+#endif
+#endif
+#if     ((387 >= GSL_INCLUDER_FIRST_CASE) && (387 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (387))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 387),
+#endif
+#endif
+#if     ((388 >= GSL_INCLUDER_FIRST_CASE) && (388 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (388))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 388),
+#endif
+#endif
+#if     ((389 >= GSL_INCLUDER_FIRST_CASE) && (389 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (389))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 389),
+#endif
+#endif
+#if     ((390 >= GSL_INCLUDER_FIRST_CASE) && (390 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (390))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 390),
+#endif
+#endif
+#if     ((391 >= GSL_INCLUDER_FIRST_CASE) && (391 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (391))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 391),
+#endif
+#endif
+#if     ((392 >= GSL_INCLUDER_FIRST_CASE) && (392 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (392))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 392),
+#endif
+#endif
+#if     ((393 >= GSL_INCLUDER_FIRST_CASE) && (393 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (393))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 393),
+#endif
+#endif
+#if     ((394 >= GSL_INCLUDER_FIRST_CASE) && (394 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (394))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 394),
+#endif
+#endif
+#if     ((395 >= GSL_INCLUDER_FIRST_CASE) && (395 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (395))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 395),
+#endif
+#endif
+#if     ((396 >= GSL_INCLUDER_FIRST_CASE) && (396 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (396))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 396),
+#endif
+#endif
+#if     ((397 >= GSL_INCLUDER_FIRST_CASE) && (397 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (397))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 397),
+#endif
+#endif
+#if     ((398 >= GSL_INCLUDER_FIRST_CASE) && (398 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (398))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 398),
+#endif
+#endif
+#if     ((399 >= GSL_INCLUDER_FIRST_CASE) && (399 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (399))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 399),
+#endif
+#endif
+#if     ((400 >= GSL_INCLUDER_FIRST_CASE) && (400 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (400))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 400),
+#endif
+#endif
+#if     ((401 >= GSL_INCLUDER_FIRST_CASE) && (401 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (401))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 401),
+#endif
+#endif
+#if     ((402 >= GSL_INCLUDER_FIRST_CASE) && (402 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (402))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 402),
+#endif
+#endif
+#if     ((403 >= GSL_INCLUDER_FIRST_CASE) && (403 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (403))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 403),
+#endif
+#endif
+#if     ((404 >= GSL_INCLUDER_FIRST_CASE) && (404 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (404))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 404),
+#endif
+#endif
+#if     ((405 >= GSL_INCLUDER_FIRST_CASE) && (405 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (405))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 405),
+#endif
+#endif
+#if     ((406 >= GSL_INCLUDER_FIRST_CASE) && (406 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (406))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 406),
+#endif
+#endif
+#if     ((407 >= GSL_INCLUDER_FIRST_CASE) && (407 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (407))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 407),
+#endif
+#endif
+#if     ((408 >= GSL_INCLUDER_FIRST_CASE) && (408 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (408))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 408),
+#endif
+#endif
+#if     ((409 >= GSL_INCLUDER_FIRST_CASE) && (409 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (409))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 409),
+#endif
+#endif
+#if     ((410 >= GSL_INCLUDER_FIRST_CASE) && (410 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (410))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 410),
+#endif
+#endif
+#if     ((411 >= GSL_INCLUDER_FIRST_CASE) && (411 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (411))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 411),
+#endif
+#endif
+#if     ((412 >= GSL_INCLUDER_FIRST_CASE) && (412 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (412))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 412),
+#endif
+#endif
+#if     ((413 >= GSL_INCLUDER_FIRST_CASE) && (413 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (413))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 413),
+#endif
+#endif
+#if     ((414 >= GSL_INCLUDER_FIRST_CASE) && (414 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (414))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 414),
+#endif
+#endif
+#if     ((415 >= GSL_INCLUDER_FIRST_CASE) && (415 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (415))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 415),
+#endif
+#endif
+#if     ((416 >= GSL_INCLUDER_FIRST_CASE) && (416 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (416))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 416),
+#endif
+#endif
+#if     ((417 >= GSL_INCLUDER_FIRST_CASE) && (417 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (417))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 417),
+#endif
+#endif
+#if     ((418 >= GSL_INCLUDER_FIRST_CASE) && (418 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (418))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 418),
+#endif
+#endif
+#if     ((419 >= GSL_INCLUDER_FIRST_CASE) && (419 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (419))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 419),
+#endif
+#endif
+#if     ((420 >= GSL_INCLUDER_FIRST_CASE) && (420 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (420))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 420),
+#endif
+#endif
+#if     ((421 >= GSL_INCLUDER_FIRST_CASE) && (421 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (421))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 421),
+#endif
+#endif
+#if     ((422 >= GSL_INCLUDER_FIRST_CASE) && (422 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (422))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 422),
+#endif
+#endif
+#if     ((423 >= GSL_INCLUDER_FIRST_CASE) && (423 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (423))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 423),
+#endif
+#endif
+#if     ((424 >= GSL_INCLUDER_FIRST_CASE) && (424 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (424))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 424),
+#endif
+#endif
+#if     ((425 >= GSL_INCLUDER_FIRST_CASE) && (425 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (425))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 425),
+#endif
+#endif
+#if     ((426 >= GSL_INCLUDER_FIRST_CASE) && (426 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (426))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 426),
+#endif
+#endif
+#if     ((427 >= GSL_INCLUDER_FIRST_CASE) && (427 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (427))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 427),
+#endif
+#endif
+#if     ((428 >= GSL_INCLUDER_FIRST_CASE) && (428 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (428))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 428),
+#endif
+#endif
+#if     ((429 >= GSL_INCLUDER_FIRST_CASE) && (429 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (429))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 429),
+#endif
+#endif
+#if     ((430 >= GSL_INCLUDER_FIRST_CASE) && (430 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (430))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 430),
+#endif
+#endif
+#if     ((431 >= GSL_INCLUDER_FIRST_CASE) && (431 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (431))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 431),
+#endif
+#endif
+#if     ((432 >= GSL_INCLUDER_FIRST_CASE) && (432 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (432))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 432),
+#endif
+#endif
+#if     ((433 >= GSL_INCLUDER_FIRST_CASE) && (433 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (433))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 433),
+#endif
+#endif
+#if     ((434 >= GSL_INCLUDER_FIRST_CASE) && (434 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (434))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 434),
+#endif
+#endif
+#if     ((435 >= GSL_INCLUDER_FIRST_CASE) && (435 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (435))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 435),
+#endif
+#endif
+#if     ((436 >= GSL_INCLUDER_FIRST_CASE) && (436 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (436))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 436),
+#endif
+#endif
+#if     ((437 >= GSL_INCLUDER_FIRST_CASE) && (437 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (437))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 437),
+#endif
+#endif
+#if     ((438 >= GSL_INCLUDER_FIRST_CASE) && (438 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (438))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 438),
+#endif
+#endif
+#if     ((439 >= GSL_INCLUDER_FIRST_CASE) && (439 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (439))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 439),
+#endif
+#endif
+#if     ((440 >= GSL_INCLUDER_FIRST_CASE) && (440 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (440))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 440),
+#endif
+#endif
+#if     ((441 >= GSL_INCLUDER_FIRST_CASE) && (441 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (441))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 441),
+#endif
+#endif
+#if     ((442 >= GSL_INCLUDER_FIRST_CASE) && (442 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (442))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 442),
+#endif
+#endif
+#if     ((443 >= GSL_INCLUDER_FIRST_CASE) && (443 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (443))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 443),
+#endif
+#endif
+#if     ((444 >= GSL_INCLUDER_FIRST_CASE) && (444 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (444))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 444),
+#endif
+#endif
+#if     ((445 >= GSL_INCLUDER_FIRST_CASE) && (445 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (445))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 445),
+#endif
+#endif
+#if     ((446 >= GSL_INCLUDER_FIRST_CASE) && (446 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (446))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 446),
+#endif
+#endif
+#if     ((447 >= GSL_INCLUDER_FIRST_CASE) && (447 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (447))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 447),
+#endif
+#endif
+#if     ((448 >= GSL_INCLUDER_FIRST_CASE) && (448 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (448))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 448),
+#endif
+#endif
+#if     ((449 >= GSL_INCLUDER_FIRST_CASE) && (449 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (449))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 449),
+#endif
+#endif
+#if     ((450 >= GSL_INCLUDER_FIRST_CASE) && (450 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (450))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 450),
+#endif
+#endif
+#if     ((451 >= GSL_INCLUDER_FIRST_CASE) && (451 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (451))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 451),
+#endif
+#endif
+#if     ((452 >= GSL_INCLUDER_FIRST_CASE) && (452 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (452))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 452),
+#endif
+#endif
+#if     ((453 >= GSL_INCLUDER_FIRST_CASE) && (453 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (453))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 453),
+#endif
+#endif
+#if     ((454 >= GSL_INCLUDER_FIRST_CASE) && (454 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (454))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 454),
+#endif
+#endif
+#if     ((455 >= GSL_INCLUDER_FIRST_CASE) && (455 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (455))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 455),
+#endif
+#endif
+#if     ((456 >= GSL_INCLUDER_FIRST_CASE) && (456 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (456))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 456),
+#endif
+#endif
+#if     ((457 >= GSL_INCLUDER_FIRST_CASE) && (457 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (457))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 457),
+#endif
+#endif
+#if     ((458 >= GSL_INCLUDER_FIRST_CASE) && (458 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (458))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 458),
+#endif
+#endif
+#if     ((459 >= GSL_INCLUDER_FIRST_CASE) && (459 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (459))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 459),
+#endif
+#endif
+#if     ((460 >= GSL_INCLUDER_FIRST_CASE) && (460 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (460))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 460),
+#endif
+#endif
+#if     ((461 >= GSL_INCLUDER_FIRST_CASE) && (461 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (461))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 461),
+#endif
+#endif
+#if     ((462 >= GSL_INCLUDER_FIRST_CASE) && (462 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (462))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 462),
+#endif
+#endif
+#if     ((463 >= GSL_INCLUDER_FIRST_CASE) && (463 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (463))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 463),
+#endif
+#endif
+#if     ((464 >= GSL_INCLUDER_FIRST_CASE) && (464 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (464))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 464),
+#endif
+#endif
+#if     ((465 >= GSL_INCLUDER_FIRST_CASE) && (465 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (465))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 465),
+#endif
+#endif
+#if     ((466 >= GSL_INCLUDER_FIRST_CASE) && (466 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (466))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 466),
+#endif
+#endif
+#if     ((467 >= GSL_INCLUDER_FIRST_CASE) && (467 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (467))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 467),
+#endif
+#endif
+#if     ((468 >= GSL_INCLUDER_FIRST_CASE) && (468 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (468))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 468),
+#endif
+#endif
+#if     ((469 >= GSL_INCLUDER_FIRST_CASE) && (469 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (469))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 469),
+#endif
+#endif
+#if     ((470 >= GSL_INCLUDER_FIRST_CASE) && (470 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (470))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 470),
+#endif
+#endif
+#if     ((471 >= GSL_INCLUDER_FIRST_CASE) && (471 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (471))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 471),
+#endif
+#endif
+#if     ((472 >= GSL_INCLUDER_FIRST_CASE) && (472 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (472))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 472),
+#endif
+#endif
+#if     ((473 >= GSL_INCLUDER_FIRST_CASE) && (473 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (473))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 473),
+#endif
+#endif
+#if     ((474 >= GSL_INCLUDER_FIRST_CASE) && (474 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (474))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 474),
+#endif
+#endif
+#if     ((475 >= GSL_INCLUDER_FIRST_CASE) && (475 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (475))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 475),
+#endif
+#endif
+#if     ((476 >= GSL_INCLUDER_FIRST_CASE) && (476 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (476))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 476),
+#endif
+#endif
+#if     ((477 >= GSL_INCLUDER_FIRST_CASE) && (477 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (477))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 477),
+#endif
+#endif
+#if     ((478 >= GSL_INCLUDER_FIRST_CASE) && (478 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (478))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 478),
+#endif
+#endif
+#if     ((479 >= GSL_INCLUDER_FIRST_CASE) && (479 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (479))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 479),
+#endif
+#endif
+#if     ((480 >= GSL_INCLUDER_FIRST_CASE) && (480 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (480))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 480),
+#endif
+#endif
+#if     ((481 >= GSL_INCLUDER_FIRST_CASE) && (481 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (481))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 481),
+#endif
+#endif
+#if     ((482 >= GSL_INCLUDER_FIRST_CASE) && (482 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (482))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 482),
+#endif
+#endif
+#if     ((483 >= GSL_INCLUDER_FIRST_CASE) && (483 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (483))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 483),
+#endif
+#endif
+#if     ((484 >= GSL_INCLUDER_FIRST_CASE) && (484 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (484))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 484),
+#endif
+#endif
+#if     ((485 >= GSL_INCLUDER_FIRST_CASE) && (485 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (485))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 485),
+#endif
+#endif
+#if     ((486 >= GSL_INCLUDER_FIRST_CASE) && (486 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (486))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 486),
+#endif
+#endif
+#if     ((487 >= GSL_INCLUDER_FIRST_CASE) && (487 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (487))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 487),
+#endif
+#endif
+#if     ((488 >= GSL_INCLUDER_FIRST_CASE) && (488 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (488))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 488),
+#endif
+#endif
+#if     ((489 >= GSL_INCLUDER_FIRST_CASE) && (489 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (489))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 489),
+#endif
+#endif
+#if     ((490 >= GSL_INCLUDER_FIRST_CASE) && (490 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (490))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 490),
+#endif
+#endif
+#if     ((491 >= GSL_INCLUDER_FIRST_CASE) && (491 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (491))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 491),
+#endif
+#endif
+#if     ((492 >= GSL_INCLUDER_FIRST_CASE) && (492 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (492))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 492),
+#endif
+#endif
+#if     ((493 >= GSL_INCLUDER_FIRST_CASE) && (493 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (493))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 493),
+#endif
+#endif
+#if     ((494 >= GSL_INCLUDER_FIRST_CASE) && (494 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (494))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 494),
+#endif
+#endif
+#if     ((495 >= GSL_INCLUDER_FIRST_CASE) && (495 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (495))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 495),
+#endif
+#endif
+#if     ((496 >= GSL_INCLUDER_FIRST_CASE) && (496 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (496))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 496),
+#endif
+#endif
+#if     ((497 >= GSL_INCLUDER_FIRST_CASE) && (497 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (497))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 497),
+#endif
+#endif
+#if     ((498 >= GSL_INCLUDER_FIRST_CASE) && (498 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (498))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 498),
+#endif
+#endif
+#if     ((499 >= GSL_INCLUDER_FIRST_CASE) && (499 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (499))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 499),
+#endif
+#endif
+#if     ((500 >= GSL_INCLUDER_FIRST_CASE) && (500 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (500))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 500),
+#endif
+#endif
+#if     ((501 >= GSL_INCLUDER_FIRST_CASE) && (501 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (501))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 501),
+#endif
+#endif
+#if     ((502 >= GSL_INCLUDER_FIRST_CASE) && (502 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (502))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 502),
+#endif
+#endif
+#if     ((503 >= GSL_INCLUDER_FIRST_CASE) && (503 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (503))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 503),
+#endif
+#endif
+#if     ((504 >= GSL_INCLUDER_FIRST_CASE) && (504 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (504))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 504),
+#endif
+#endif
+#if     ((505 >= GSL_INCLUDER_FIRST_CASE) && (505 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (505))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 505),
+#endif
+#endif
+#if     ((506 >= GSL_INCLUDER_FIRST_CASE) && (506 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (506))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 506),
+#endif
+#endif
+#if     ((507 >= GSL_INCLUDER_FIRST_CASE) && (507 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (507))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 507),
+#endif
+#endif
+#if     ((508 >= GSL_INCLUDER_FIRST_CASE) && (508 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (508))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 508),
+#endif
+#endif
+#if     ((509 >= GSL_INCLUDER_FIRST_CASE) && (509 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (509))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 509),
+#endif
+#endif
+#if     ((510 >= GSL_INCLUDER_FIRST_CASE) && (510 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (510))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 510),
+#endif
+#endif
+#if     ((511 >= GSL_INCLUDER_FIRST_CASE) && (511 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (511))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 511),
+#endif
+#endif
+#if     ((512 >= GSL_INCLUDER_FIRST_CASE) && (512 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (512))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 512),
+#endif
+#endif
+#if     ((513 >= GSL_INCLUDER_FIRST_CASE) && (513 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (513))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 513),
+#endif
+#endif
+#if     ((514 >= GSL_INCLUDER_FIRST_CASE) && (514 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (514))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 514),
+#endif
+#endif
+#if     ((515 >= GSL_INCLUDER_FIRST_CASE) && (515 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (515))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 515),
+#endif
+#endif
+#if     ((516 >= GSL_INCLUDER_FIRST_CASE) && (516 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (516))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 516),
+#endif
+#endif
+#if     ((517 >= GSL_INCLUDER_FIRST_CASE) && (517 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (517))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 517),
+#endif
+#endif
+#if     ((518 >= GSL_INCLUDER_FIRST_CASE) && (518 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (518))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 518),
+#endif
+#endif
+#if     ((519 >= GSL_INCLUDER_FIRST_CASE) && (519 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (519))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 519),
+#endif
+#endif
+#if     ((520 >= GSL_INCLUDER_FIRST_CASE) && (520 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (520))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 520),
+#endif
+#endif
+#if     ((521 >= GSL_INCLUDER_FIRST_CASE) && (521 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (521))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 521),
+#endif
+#endif
+#if     ((522 >= GSL_INCLUDER_FIRST_CASE) && (522 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (522))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 522),
+#endif
+#endif
+#if     ((523 >= GSL_INCLUDER_FIRST_CASE) && (523 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (523))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 523),
+#endif
+#endif
+#if     ((524 >= GSL_INCLUDER_FIRST_CASE) && (524 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (524))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 524),
+#endif
+#endif
+#if     ((525 >= GSL_INCLUDER_FIRST_CASE) && (525 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (525))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 525),
+#endif
+#endif
+#if     ((526 >= GSL_INCLUDER_FIRST_CASE) && (526 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (526))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 526),
+#endif
+#endif
+#if     ((527 >= GSL_INCLUDER_FIRST_CASE) && (527 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (527))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 527),
+#endif
+#endif
+#if     ((528 >= GSL_INCLUDER_FIRST_CASE) && (528 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (528))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 528),
+#endif
+#endif
+#if     ((529 >= GSL_INCLUDER_FIRST_CASE) && (529 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (529))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 529),
+#endif
+#endif
+#if     ((530 >= GSL_INCLUDER_FIRST_CASE) && (530 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (530))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 530),
+#endif
+#endif
+#if     ((531 >= GSL_INCLUDER_FIRST_CASE) && (531 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (531))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 531),
+#endif
+#endif
+#if     ((532 >= GSL_INCLUDER_FIRST_CASE) && (532 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (532))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 532),
+#endif
+#endif
+#if     ((533 >= GSL_INCLUDER_FIRST_CASE) && (533 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (533))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 533),
+#endif
+#endif
+#if     ((534 >= GSL_INCLUDER_FIRST_CASE) && (534 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (534))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 534),
+#endif
+#endif
+#if     ((535 >= GSL_INCLUDER_FIRST_CASE) && (535 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (535))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 535),
+#endif
+#endif
+#if     ((536 >= GSL_INCLUDER_FIRST_CASE) && (536 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (536))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 536),
+#endif
+#endif
+#if     ((537 >= GSL_INCLUDER_FIRST_CASE) && (537 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (537))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 537),
+#endif
+#endif
+#if     ((538 >= GSL_INCLUDER_FIRST_CASE) && (538 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (538))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 538),
+#endif
+#endif
+#if     ((539 >= GSL_INCLUDER_FIRST_CASE) && (539 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (539))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 539),
+#endif
+#endif
+#if     ((540 >= GSL_INCLUDER_FIRST_CASE) && (540 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (540))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 540),
+#endif
+#endif
+#if     ((541 >= GSL_INCLUDER_FIRST_CASE) && (541 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (541))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 541),
+#endif
+#endif
+#if     ((542 >= GSL_INCLUDER_FIRST_CASE) && (542 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (542))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 542),
+#endif
+#endif
+#if     ((543 >= GSL_INCLUDER_FIRST_CASE) && (543 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (543))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 543),
+#endif
+#endif
+#if     ((544 >= GSL_INCLUDER_FIRST_CASE) && (544 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (544))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 544),
+#endif
+#endif
+#if     ((545 >= GSL_INCLUDER_FIRST_CASE) && (545 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (545))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 545),
+#endif
+#endif
+#if     ((546 >= GSL_INCLUDER_FIRST_CASE) && (546 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (546))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 546),
+#endif
+#endif
+#if     ((547 >= GSL_INCLUDER_FIRST_CASE) && (547 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (547))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 547),
+#endif
+#endif
+#if     ((548 >= GSL_INCLUDER_FIRST_CASE) && (548 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (548))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 548),
+#endif
+#endif
+#if     ((549 >= GSL_INCLUDER_FIRST_CASE) && (549 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (549))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 549),
+#endif
+#endif
+#if     ((550 >= GSL_INCLUDER_FIRST_CASE) && (550 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (550))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 550),
+#endif
+#endif
+#if     ((551 >= GSL_INCLUDER_FIRST_CASE) && (551 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (551))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 551),
+#endif
+#endif
+#if     ((552 >= GSL_INCLUDER_FIRST_CASE) && (552 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (552))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 552),
+#endif
+#endif
+#if     ((553 >= GSL_INCLUDER_FIRST_CASE) && (553 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (553))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 553),
+#endif
+#endif
+#if     ((554 >= GSL_INCLUDER_FIRST_CASE) && (554 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (554))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 554),
+#endif
+#endif
+#if     ((555 >= GSL_INCLUDER_FIRST_CASE) && (555 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (555))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 555),
+#endif
+#endif
+#if     ((556 >= GSL_INCLUDER_FIRST_CASE) && (556 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (556))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 556),
+#endif
+#endif
+#if     ((557 >= GSL_INCLUDER_FIRST_CASE) && (557 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (557))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 557),
+#endif
+#endif
+#if     ((558 >= GSL_INCLUDER_FIRST_CASE) && (558 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (558))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 558),
+#endif
+#endif
+#if     ((559 >= GSL_INCLUDER_FIRST_CASE) && (559 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (559))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 559),
+#endif
+#endif
+#if     ((560 >= GSL_INCLUDER_FIRST_CASE) && (560 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (560))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 560),
+#endif
+#endif
+#if     ((561 >= GSL_INCLUDER_FIRST_CASE) && (561 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (561))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 561),
+#endif
+#endif
+#if     ((562 >= GSL_INCLUDER_FIRST_CASE) && (562 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (562))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 562),
+#endif
+#endif
+#if     ((563 >= GSL_INCLUDER_FIRST_CASE) && (563 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (563))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 563),
+#endif
+#endif
+#if     ((564 >= GSL_INCLUDER_FIRST_CASE) && (564 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (564))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 564),
+#endif
+#endif
+#if     ((565 >= GSL_INCLUDER_FIRST_CASE) && (565 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (565))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 565),
+#endif
+#endif
+#if     ((566 >= GSL_INCLUDER_FIRST_CASE) && (566 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (566))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 566),
+#endif
+#endif
+#if     ((567 >= GSL_INCLUDER_FIRST_CASE) && (567 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (567))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 567),
+#endif
+#endif
+#if     ((568 >= GSL_INCLUDER_FIRST_CASE) && (568 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (568))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 568),
+#endif
+#endif
+#if     ((569 >= GSL_INCLUDER_FIRST_CASE) && (569 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (569))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 569),
+#endif
+#endif
+#if     ((570 >= GSL_INCLUDER_FIRST_CASE) && (570 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (570))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 570),
+#endif
+#endif
+#if     ((571 >= GSL_INCLUDER_FIRST_CASE) && (571 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (571))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 571),
+#endif
+#endif
+#if     ((572 >= GSL_INCLUDER_FIRST_CASE) && (572 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (572))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 572),
+#endif
+#endif
+#if     ((573 >= GSL_INCLUDER_FIRST_CASE) && (573 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (573))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 573),
+#endif
+#endif
+#if     ((574 >= GSL_INCLUDER_FIRST_CASE) && (574 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (574))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 574),
+#endif
+#endif
+#if     ((575 >= GSL_INCLUDER_FIRST_CASE) && (575 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (575))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 575),
+#endif
+#endif
+#if     ((576 >= GSL_INCLUDER_FIRST_CASE) && (576 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (576))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 576),
+#endif
+#endif
+#if     ((577 >= GSL_INCLUDER_FIRST_CASE) && (577 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (577))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 577),
+#endif
+#endif
+#if     ((578 >= GSL_INCLUDER_FIRST_CASE) && (578 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (578))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 578),
+#endif
+#endif
+#if     ((579 >= GSL_INCLUDER_FIRST_CASE) && (579 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (579))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 579),
+#endif
+#endif
+#if     ((580 >= GSL_INCLUDER_FIRST_CASE) && (580 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (580))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 580),
+#endif
+#endif
+#if     ((581 >= GSL_INCLUDER_FIRST_CASE) && (581 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (581))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 581),
+#endif
+#endif
+#if     ((582 >= GSL_INCLUDER_FIRST_CASE) && (582 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (582))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 582),
+#endif
+#endif
+#if     ((583 >= GSL_INCLUDER_FIRST_CASE) && (583 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (583))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 583),
+#endif
+#endif
+#if     ((584 >= GSL_INCLUDER_FIRST_CASE) && (584 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (584))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 584),
+#endif
+#endif
+#if     ((585 >= GSL_INCLUDER_FIRST_CASE) && (585 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (585))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 585),
+#endif
+#endif
+#if     ((586 >= GSL_INCLUDER_FIRST_CASE) && (586 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (586))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 586),
+#endif
+#endif
+#if     ((587 >= GSL_INCLUDER_FIRST_CASE) && (587 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (587))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 587),
+#endif
+#endif
+#if     ((588 >= GSL_INCLUDER_FIRST_CASE) && (588 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (588))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 588),
+#endif
+#endif
+#if     ((589 >= GSL_INCLUDER_FIRST_CASE) && (589 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (589))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 589),
+#endif
+#endif
+#if     ((590 >= GSL_INCLUDER_FIRST_CASE) && (590 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (590))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 590),
+#endif
+#endif
+#if     ((591 >= GSL_INCLUDER_FIRST_CASE) && (591 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (591))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 591),
+#endif
+#endif
+#if     ((592 >= GSL_INCLUDER_FIRST_CASE) && (592 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (592))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 592),
+#endif
+#endif
+#if     ((593 >= GSL_INCLUDER_FIRST_CASE) && (593 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (593))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 593),
+#endif
+#endif
+#if     ((594 >= GSL_INCLUDER_FIRST_CASE) && (594 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (594))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 594),
+#endif
+#endif
+#if     ((595 >= GSL_INCLUDER_FIRST_CASE) && (595 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (595))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 595),
+#endif
+#endif
+#if     ((596 >= GSL_INCLUDER_FIRST_CASE) && (596 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (596))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 596),
+#endif
+#endif
+#if     ((597 >= GSL_INCLUDER_FIRST_CASE) && (597 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (597))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 597),
+#endif
+#endif
+#if     ((598 >= GSL_INCLUDER_FIRST_CASE) && (598 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (598))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 598),
+#endif
+#endif
+#if     ((599 >= GSL_INCLUDER_FIRST_CASE) && (599 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (599))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 599),
+#endif
+#endif
+#if     ((600 >= GSL_INCLUDER_FIRST_CASE) && (600 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (600))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 600),
+#endif
+#endif
+#if     ((601 >= GSL_INCLUDER_FIRST_CASE) && (601 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (601))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 601),
+#endif
+#endif
+#if     ((602 >= GSL_INCLUDER_FIRST_CASE) && (602 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (602))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 602),
+#endif
+#endif
+#if     ((603 >= GSL_INCLUDER_FIRST_CASE) && (603 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (603))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 603),
+#endif
+#endif
+#if     ((604 >= GSL_INCLUDER_FIRST_CASE) && (604 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (604))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 604),
+#endif
+#endif
+#if     ((605 >= GSL_INCLUDER_FIRST_CASE) && (605 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (605))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 605),
+#endif
+#endif
+#if     ((606 >= GSL_INCLUDER_FIRST_CASE) && (606 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (606))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 606),
+#endif
+#endif
+#if     ((607 >= GSL_INCLUDER_FIRST_CASE) && (607 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (607))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 607),
+#endif
+#endif
+#if     ((608 >= GSL_INCLUDER_FIRST_CASE) && (608 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (608))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 608),
+#endif
+#endif
+#if     ((609 >= GSL_INCLUDER_FIRST_CASE) && (609 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (609))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 609),
+#endif
+#endif
+#if     ((610 >= GSL_INCLUDER_FIRST_CASE) && (610 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (610))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 610),
+#endif
+#endif
+#if     ((611 >= GSL_INCLUDER_FIRST_CASE) && (611 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (611))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 611),
+#endif
+#endif
+#if     ((612 >= GSL_INCLUDER_FIRST_CASE) && (612 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (612))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 612),
+#endif
+#endif
+#if     ((613 >= GSL_INCLUDER_FIRST_CASE) && (613 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (613))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 613),
+#endif
+#endif
+#if     ((614 >= GSL_INCLUDER_FIRST_CASE) && (614 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (614))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 614),
+#endif
+#endif
+#if     ((615 >= GSL_INCLUDER_FIRST_CASE) && (615 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (615))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 615),
+#endif
+#endif
+#if     ((616 >= GSL_INCLUDER_FIRST_CASE) && (616 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (616))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 616),
+#endif
+#endif
+#if     ((617 >= GSL_INCLUDER_FIRST_CASE) && (617 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (617))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 617),
+#endif
+#endif
+#if     ((618 >= GSL_INCLUDER_FIRST_CASE) && (618 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (618))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 618),
+#endif
+#endif
+#if     ((619 >= GSL_INCLUDER_FIRST_CASE) && (619 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (619))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 619),
+#endif
+#endif
+#if     ((620 >= GSL_INCLUDER_FIRST_CASE) && (620 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (620))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 620),
+#endif
+#endif
+#if     ((621 >= GSL_INCLUDER_FIRST_CASE) && (621 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (621))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 621),
+#endif
+#endif
+#if     ((622 >= GSL_INCLUDER_FIRST_CASE) && (622 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (622))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 622),
+#endif
+#endif
+#if     ((623 >= GSL_INCLUDER_FIRST_CASE) && (623 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (623))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 623),
+#endif
+#endif
+#if     ((624 >= GSL_INCLUDER_FIRST_CASE) && (624 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (624))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 624),
+#endif
+#endif
+#if     ((625 >= GSL_INCLUDER_FIRST_CASE) && (625 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (625))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 625),
+#endif
+#endif
+#if     ((626 >= GSL_INCLUDER_FIRST_CASE) && (626 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (626))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 626),
+#endif
+#endif
+#if     ((627 >= GSL_INCLUDER_FIRST_CASE) && (627 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (627))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 627),
+#endif
+#endif
+#if     ((628 >= GSL_INCLUDER_FIRST_CASE) && (628 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (628))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 628),
+#endif
+#endif
+#if     ((629 >= GSL_INCLUDER_FIRST_CASE) && (629 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (629))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 629),
+#endif
+#endif
+#if     ((630 >= GSL_INCLUDER_FIRST_CASE) && (630 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (630))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 630),
+#endif
+#endif
+#if     ((631 >= GSL_INCLUDER_FIRST_CASE) && (631 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (631))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 631),
+#endif
+#endif
+#if     ((632 >= GSL_INCLUDER_FIRST_CASE) && (632 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (632))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 632),
+#endif
+#endif
+#if     ((633 >= GSL_INCLUDER_FIRST_CASE) && (633 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (633))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 633),
+#endif
+#endif
+#if     ((634 >= GSL_INCLUDER_FIRST_CASE) && (634 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (634))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 634),
+#endif
+#endif
+#if     ((635 >= GSL_INCLUDER_FIRST_CASE) && (635 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (635))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 635),
+#endif
+#endif
+#if     ((636 >= GSL_INCLUDER_FIRST_CASE) && (636 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (636))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 636),
+#endif
+#endif
+#if     ((637 >= GSL_INCLUDER_FIRST_CASE) && (637 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (637))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 637),
+#endif
+#endif
+#if     ((638 >= GSL_INCLUDER_FIRST_CASE) && (638 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (638))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 638),
+#endif
+#endif
+#if     ((639 >= GSL_INCLUDER_FIRST_CASE) && (639 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (639))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 639),
+#endif
+#endif
+#if     ((640 >= GSL_INCLUDER_FIRST_CASE) && (640 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (640))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 640),
+#endif
+#endif
+#if     ((641 >= GSL_INCLUDER_FIRST_CASE) && (641 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (641))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 641),
+#endif
+#endif
+#if     ((642 >= GSL_INCLUDER_FIRST_CASE) && (642 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (642))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 642),
+#endif
+#endif
+#if     ((643 >= GSL_INCLUDER_FIRST_CASE) && (643 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (643))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 643),
+#endif
+#endif
+#if     ((644 >= GSL_INCLUDER_FIRST_CASE) && (644 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (644))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 644),
+#endif
+#endif
+#if     ((645 >= GSL_INCLUDER_FIRST_CASE) && (645 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (645))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 645),
+#endif
+#endif
+#if     ((646 >= GSL_INCLUDER_FIRST_CASE) && (646 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (646))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 646),
+#endif
+#endif
+#if     ((647 >= GSL_INCLUDER_FIRST_CASE) && (647 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (647))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 647),
+#endif
+#endif
+#if     ((648 >= GSL_INCLUDER_FIRST_CASE) && (648 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (648))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 648),
+#endif
+#endif
+#if     ((649 >= GSL_INCLUDER_FIRST_CASE) && (649 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (649))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 649),
+#endif
+#endif
+#if     ((650 >= GSL_INCLUDER_FIRST_CASE) && (650 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (650))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 650),
+#endif
+#endif
+#if     ((651 >= GSL_INCLUDER_FIRST_CASE) && (651 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (651))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 651),
+#endif
+#endif
+#if     ((652 >= GSL_INCLUDER_FIRST_CASE) && (652 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (652))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 652),
+#endif
+#endif
+#if     ((653 >= GSL_INCLUDER_FIRST_CASE) && (653 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (653))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 653),
+#endif
+#endif
+#if     ((654 >= GSL_INCLUDER_FIRST_CASE) && (654 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (654))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 654),
+#endif
+#endif
+#if     ((655 >= GSL_INCLUDER_FIRST_CASE) && (655 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (655))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 655),
+#endif
+#endif
+#if     ((656 >= GSL_INCLUDER_FIRST_CASE) && (656 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (656))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 656),
+#endif
+#endif
+#if     ((657 >= GSL_INCLUDER_FIRST_CASE) && (657 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (657))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 657),
+#endif
+#endif
+#if     ((658 >= GSL_INCLUDER_FIRST_CASE) && (658 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (658))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 658),
+#endif
+#endif
+#if     ((659 >= GSL_INCLUDER_FIRST_CASE) && (659 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (659))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 659),
+#endif
+#endif
+#if     ((660 >= GSL_INCLUDER_FIRST_CASE) && (660 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (660))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 660),
+#endif
+#endif
+#if     ((661 >= GSL_INCLUDER_FIRST_CASE) && (661 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (661))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 661),
+#endif
+#endif
+#if     ((662 >= GSL_INCLUDER_FIRST_CASE) && (662 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (662))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 662),
+#endif
+#endif
+#if     ((663 >= GSL_INCLUDER_FIRST_CASE) && (663 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (663))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 663),
+#endif
+#endif
+#if     ((664 >= GSL_INCLUDER_FIRST_CASE) && (664 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (664))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 664),
+#endif
+#endif
+#if     ((665 >= GSL_INCLUDER_FIRST_CASE) && (665 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (665))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 665),
+#endif
+#endif
+#if     ((666 >= GSL_INCLUDER_FIRST_CASE) && (666 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (666))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 666),
+#endif
+#endif
+#if     ((667 >= GSL_INCLUDER_FIRST_CASE) && (667 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (667))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 667),
+#endif
+#endif
+#if     ((668 >= GSL_INCLUDER_FIRST_CASE) && (668 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (668))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 668),
+#endif
+#endif
+#if     ((669 >= GSL_INCLUDER_FIRST_CASE) && (669 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (669))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 669),
+#endif
+#endif
+#if     ((670 >= GSL_INCLUDER_FIRST_CASE) && (670 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (670))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 670),
+#endif
+#endif
+#if     ((671 >= GSL_INCLUDER_FIRST_CASE) && (671 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (671))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 671),
+#endif
+#endif
+#if     ((672 >= GSL_INCLUDER_FIRST_CASE) && (672 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (672))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 672),
+#endif
+#endif
+#if     ((673 >= GSL_INCLUDER_FIRST_CASE) && (673 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (673))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 673),
+#endif
+#endif
+#if     ((674 >= GSL_INCLUDER_FIRST_CASE) && (674 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (674))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 674),
+#endif
+#endif
+#if     ((675 >= GSL_INCLUDER_FIRST_CASE) && (675 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (675))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 675),
+#endif
+#endif
+#if     ((676 >= GSL_INCLUDER_FIRST_CASE) && (676 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (676))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 676),
+#endif
+#endif
+#if     ((677 >= GSL_INCLUDER_FIRST_CASE) && (677 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (677))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 677),
+#endif
+#endif
+#if     ((678 >= GSL_INCLUDER_FIRST_CASE) && (678 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (678))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 678),
+#endif
+#endif
+#if     ((679 >= GSL_INCLUDER_FIRST_CASE) && (679 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (679))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 679),
+#endif
+#endif
+#if     ((680 >= GSL_INCLUDER_FIRST_CASE) && (680 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (680))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 680),
+#endif
+#endif
+#if     ((681 >= GSL_INCLUDER_FIRST_CASE) && (681 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (681))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 681),
+#endif
+#endif
+#if     ((682 >= GSL_INCLUDER_FIRST_CASE) && (682 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (682))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 682),
+#endif
+#endif
+#if     ((683 >= GSL_INCLUDER_FIRST_CASE) && (683 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (683))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 683),
+#endif
+#endif
+#if     ((684 >= GSL_INCLUDER_FIRST_CASE) && (684 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (684))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 684),
+#endif
+#endif
+#if     ((685 >= GSL_INCLUDER_FIRST_CASE) && (685 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (685))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 685),
+#endif
+#endif
+#if     ((686 >= GSL_INCLUDER_FIRST_CASE) && (686 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (686))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 686),
+#endif
+#endif
+#if     ((687 >= GSL_INCLUDER_FIRST_CASE) && (687 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (687))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 687),
+#endif
+#endif
+#if     ((688 >= GSL_INCLUDER_FIRST_CASE) && (688 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (688))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 688),
+#endif
+#endif
+#if     ((689 >= GSL_INCLUDER_FIRST_CASE) && (689 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (689))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 689),
+#endif
+#endif
+#if     ((690 >= GSL_INCLUDER_FIRST_CASE) && (690 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (690))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 690),
+#endif
+#endif
+#if     ((691 >= GSL_INCLUDER_FIRST_CASE) && (691 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (691))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 691),
+#endif
+#endif
+#if     ((692 >= GSL_INCLUDER_FIRST_CASE) && (692 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (692))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 692),
+#endif
+#endif
+#if     ((693 >= GSL_INCLUDER_FIRST_CASE) && (693 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (693))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 693),
+#endif
+#endif
+#if     ((694 >= GSL_INCLUDER_FIRST_CASE) && (694 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (694))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 694),
+#endif
+#endif
+#if     ((695 >= GSL_INCLUDER_FIRST_CASE) && (695 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (695))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 695),
+#endif
+#endif
+#if     ((696 >= GSL_INCLUDER_FIRST_CASE) && (696 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (696))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 696),
+#endif
+#endif
+#if     ((697 >= GSL_INCLUDER_FIRST_CASE) && (697 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (697))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 697),
+#endif
+#endif
+#if     ((698 >= GSL_INCLUDER_FIRST_CASE) && (698 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (698))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 698),
+#endif
+#endif
+#if     ((699 >= GSL_INCLUDER_FIRST_CASE) && (699 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (699))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 699),
+#endif
+#endif
+#if     ((700 >= GSL_INCLUDER_FIRST_CASE) && (700 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (700))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 700),
+#endif
+#endif
+#if     ((701 >= GSL_INCLUDER_FIRST_CASE) && (701 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (701))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 701),
+#endif
+#endif
+#if     ((702 >= GSL_INCLUDER_FIRST_CASE) && (702 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (702))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 702),
+#endif
+#endif
+#if     ((703 >= GSL_INCLUDER_FIRST_CASE) && (703 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (703))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 703),
+#endif
+#endif
+#if     ((704 >= GSL_INCLUDER_FIRST_CASE) && (704 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (704))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 704),
+#endif
+#endif
+#if     ((705 >= GSL_INCLUDER_FIRST_CASE) && (705 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (705))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 705),
+#endif
+#endif
+#if     ((706 >= GSL_INCLUDER_FIRST_CASE) && (706 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (706))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 706),
+#endif
+#endif
+#if     ((707 >= GSL_INCLUDER_FIRST_CASE) && (707 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (707))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 707),
+#endif
+#endif
+#if     ((708 >= GSL_INCLUDER_FIRST_CASE) && (708 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (708))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 708),
+#endif
+#endif
+#if     ((709 >= GSL_INCLUDER_FIRST_CASE) && (709 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (709))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 709),
+#endif
+#endif
+#if     ((710 >= GSL_INCLUDER_FIRST_CASE) && (710 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (710))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 710),
+#endif
+#endif
+#if     ((711 >= GSL_INCLUDER_FIRST_CASE) && (711 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (711))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 711),
+#endif
+#endif
+#if     ((712 >= GSL_INCLUDER_FIRST_CASE) && (712 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (712))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 712),
+#endif
+#endif
+#if     ((713 >= GSL_INCLUDER_FIRST_CASE) && (713 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (713))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 713),
+#endif
+#endif
+#if     ((714 >= GSL_INCLUDER_FIRST_CASE) && (714 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (714))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 714),
+#endif
+#endif
+#if     ((715 >= GSL_INCLUDER_FIRST_CASE) && (715 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (715))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 715),
+#endif
+#endif
+#if     ((716 >= GSL_INCLUDER_FIRST_CASE) && (716 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (716))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 716),
+#endif
+#endif
+#if     ((717 >= GSL_INCLUDER_FIRST_CASE) && (717 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (717))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 717),
+#endif
+#endif
+#if     ((718 >= GSL_INCLUDER_FIRST_CASE) && (718 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (718))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 718),
+#endif
+#endif
+#if     ((719 >= GSL_INCLUDER_FIRST_CASE) && (719 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (719))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 719),
+#endif
+#endif
+#if     ((720 >= GSL_INCLUDER_FIRST_CASE) && (720 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (720))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 720),
+#endif
+#endif
+#if     ((721 >= GSL_INCLUDER_FIRST_CASE) && (721 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (721))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 721),
+#endif
+#endif
+#if     ((722 >= GSL_INCLUDER_FIRST_CASE) && (722 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (722))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 722),
+#endif
+#endif
+#if     ((723 >= GSL_INCLUDER_FIRST_CASE) && (723 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (723))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 723),
+#endif
+#endif
+#if     ((724 >= GSL_INCLUDER_FIRST_CASE) && (724 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (724))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 724),
+#endif
+#endif
+#if     ((725 >= GSL_INCLUDER_FIRST_CASE) && (725 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (725))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 725),
+#endif
+#endif
+#if     ((726 >= GSL_INCLUDER_FIRST_CASE) && (726 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (726))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 726),
+#endif
+#endif
+#if     ((727 >= GSL_INCLUDER_FIRST_CASE) && (727 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (727))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 727),
+#endif
+#endif
+#if     ((728 >= GSL_INCLUDER_FIRST_CASE) && (728 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (728))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 728),
+#endif
+#endif
+#if     ((729 >= GSL_INCLUDER_FIRST_CASE) && (729 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (729))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 729),
+#endif
+#endif
+#if     ((730 >= GSL_INCLUDER_FIRST_CASE) && (730 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (730))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 730),
+#endif
+#endif
+#if     ((731 >= GSL_INCLUDER_FIRST_CASE) && (731 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (731))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 731),
+#endif
+#endif
+#if     ((732 >= GSL_INCLUDER_FIRST_CASE) && (732 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (732))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 732),
+#endif
+#endif
+#if     ((733 >= GSL_INCLUDER_FIRST_CASE) && (733 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (733))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 733),
+#endif
+#endif
+#if     ((734 >= GSL_INCLUDER_FIRST_CASE) && (734 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (734))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 734),
+#endif
+#endif
+#if     ((735 >= GSL_INCLUDER_FIRST_CASE) && (735 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (735))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 735),
+#endif
+#endif
+#if     ((736 >= GSL_INCLUDER_FIRST_CASE) && (736 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (736))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 736),
+#endif
+#endif
+#if     ((737 >= GSL_INCLUDER_FIRST_CASE) && (737 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (737))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 737),
+#endif
+#endif
+#if     ((738 >= GSL_INCLUDER_FIRST_CASE) && (738 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (738))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 738),
+#endif
+#endif
+#if     ((739 >= GSL_INCLUDER_FIRST_CASE) && (739 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (739))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 739),
+#endif
+#endif
+#if     ((740 >= GSL_INCLUDER_FIRST_CASE) && (740 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (740))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 740),
+#endif
+#endif
+#if     ((741 >= GSL_INCLUDER_FIRST_CASE) && (741 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (741))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 741),
+#endif
+#endif
+#if     ((742 >= GSL_INCLUDER_FIRST_CASE) && (742 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (742))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 742),
+#endif
+#endif
+#if     ((743 >= GSL_INCLUDER_FIRST_CASE) && (743 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (743))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 743),
+#endif
+#endif
+#if     ((744 >= GSL_INCLUDER_FIRST_CASE) && (744 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (744))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 744),
+#endif
+#endif
+#if     ((745 >= GSL_INCLUDER_FIRST_CASE) && (745 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (745))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 745),
+#endif
+#endif
+#if     ((746 >= GSL_INCLUDER_FIRST_CASE) && (746 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (746))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 746),
+#endif
+#endif
+#if     ((747 >= GSL_INCLUDER_FIRST_CASE) && (747 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (747))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 747),
+#endif
+#endif
+#if     ((748 >= GSL_INCLUDER_FIRST_CASE) && (748 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (748))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 748),
+#endif
+#endif
+#if     ((749 >= GSL_INCLUDER_FIRST_CASE) && (749 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (749))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 749),
+#endif
+#endif
+#if     ((750 >= GSL_INCLUDER_FIRST_CASE) && (750 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (750))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 750),
+#endif
+#endif
+#if     ((751 >= GSL_INCLUDER_FIRST_CASE) && (751 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (751))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 751),
+#endif
+#endif
+#if     ((752 >= GSL_INCLUDER_FIRST_CASE) && (752 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (752))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 752),
+#endif
+#endif
+#if     ((753 >= GSL_INCLUDER_FIRST_CASE) && (753 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (753))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 753),
+#endif
+#endif
+#if     ((754 >= GSL_INCLUDER_FIRST_CASE) && (754 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (754))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 754),
+#endif
+#endif
+#if     ((755 >= GSL_INCLUDER_FIRST_CASE) && (755 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (755))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 755),
+#endif
+#endif
+#if     ((756 >= GSL_INCLUDER_FIRST_CASE) && (756 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (756))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 756),
+#endif
+#endif
+#if     ((757 >= GSL_INCLUDER_FIRST_CASE) && (757 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (757))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 757),
+#endif
+#endif
+#if     ((758 >= GSL_INCLUDER_FIRST_CASE) && (758 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (758))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 758),
+#endif
+#endif
+#if     ((759 >= GSL_INCLUDER_FIRST_CASE) && (759 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (759))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 759),
+#endif
+#endif
+#if     ((760 >= GSL_INCLUDER_FIRST_CASE) && (760 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (760))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 760),
+#endif
+#endif
+#if     ((761 >= GSL_INCLUDER_FIRST_CASE) && (761 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (761))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 761),
+#endif
+#endif
+#if     ((762 >= GSL_INCLUDER_FIRST_CASE) && (762 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (762))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 762),
+#endif
+#endif
+#if     ((763 >= GSL_INCLUDER_FIRST_CASE) && (763 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (763))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 763),
+#endif
+#endif
+#if     ((764 >= GSL_INCLUDER_FIRST_CASE) && (764 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (764))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 764),
+#endif
+#endif
+#if     ((765 >= GSL_INCLUDER_FIRST_CASE) && (765 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (765))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 765),
+#endif
+#endif
+#if     ((766 >= GSL_INCLUDER_FIRST_CASE) && (766 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (766))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 766),
+#endif
+#endif
+#if     ((767 >= GSL_INCLUDER_FIRST_CASE) && (767 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (767))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 767),
+#endif
+#endif
+#if     ((768 >= GSL_INCLUDER_FIRST_CASE) && (768 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (768))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 768),
+#endif
+#endif
+#if     ((769 >= GSL_INCLUDER_FIRST_CASE) && (769 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (769))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 769),
+#endif
+#endif
+#if     ((770 >= GSL_INCLUDER_FIRST_CASE) && (770 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (770))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 770),
+#endif
+#endif
+#if     ((771 >= GSL_INCLUDER_FIRST_CASE) && (771 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (771))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 771),
+#endif
+#endif
+#if     ((772 >= GSL_INCLUDER_FIRST_CASE) && (772 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (772))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 772),
+#endif
+#endif
+#if     ((773 >= GSL_INCLUDER_FIRST_CASE) && (773 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (773))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 773),
+#endif
+#endif
+#if     ((774 >= GSL_INCLUDER_FIRST_CASE) && (774 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (774))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 774),
+#endif
+#endif
+#if     ((775 >= GSL_INCLUDER_FIRST_CASE) && (775 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (775))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 775),
+#endif
+#endif
+#if     ((776 >= GSL_INCLUDER_FIRST_CASE) && (776 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (776))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 776),
+#endif
+#endif
+#if     ((777 >= GSL_INCLUDER_FIRST_CASE) && (777 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (777))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 777),
+#endif
+#endif
+#if     ((778 >= GSL_INCLUDER_FIRST_CASE) && (778 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (778))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 778),
+#endif
+#endif
+#if     ((779 >= GSL_INCLUDER_FIRST_CASE) && (779 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (779))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 779),
+#endif
+#endif
+#if     ((780 >= GSL_INCLUDER_FIRST_CASE) && (780 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (780))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 780),
+#endif
+#endif
+#if     ((781 >= GSL_INCLUDER_FIRST_CASE) && (781 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (781))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 781),
+#endif
+#endif
+#if     ((782 >= GSL_INCLUDER_FIRST_CASE) && (782 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (782))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 782),
+#endif
+#endif
+#if     ((783 >= GSL_INCLUDER_FIRST_CASE) && (783 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (783))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 783),
+#endif
+#endif
+#if     ((784 >= GSL_INCLUDER_FIRST_CASE) && (784 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (784))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 784),
+#endif
+#endif
+#if     ((785 >= GSL_INCLUDER_FIRST_CASE) && (785 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (785))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 785),
+#endif
+#endif
+#if     ((786 >= GSL_INCLUDER_FIRST_CASE) && (786 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (786))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 786),
+#endif
+#endif
+#if     ((787 >= GSL_INCLUDER_FIRST_CASE) && (787 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (787))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 787),
+#endif
+#endif
+#if     ((788 >= GSL_INCLUDER_FIRST_CASE) && (788 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (788))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 788),
+#endif
+#endif
+#if     ((789 >= GSL_INCLUDER_FIRST_CASE) && (789 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (789))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 789),
+#endif
+#endif
+#if     ((790 >= GSL_INCLUDER_FIRST_CASE) && (790 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (790))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 790),
+#endif
+#endif
+#if     ((791 >= GSL_INCLUDER_FIRST_CASE) && (791 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (791))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 791),
+#endif
+#endif
+#if     ((792 >= GSL_INCLUDER_FIRST_CASE) && (792 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (792))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 792),
+#endif
+#endif
+#if     ((793 >= GSL_INCLUDER_FIRST_CASE) && (793 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (793))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 793),
+#endif
+#endif
+#if     ((794 >= GSL_INCLUDER_FIRST_CASE) && (794 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (794))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 794),
+#endif
+#endif
+#if     ((795 >= GSL_INCLUDER_FIRST_CASE) && (795 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (795))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 795),
+#endif
+#endif
+#if     ((796 >= GSL_INCLUDER_FIRST_CASE) && (796 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (796))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 796),
+#endif
+#endif
+#if     ((797 >= GSL_INCLUDER_FIRST_CASE) && (797 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (797))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 797),
+#endif
+#endif
+#if     ((798 >= GSL_INCLUDER_FIRST_CASE) && (798 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (798))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 798),
+#endif
+#endif
+#if     ((799 >= GSL_INCLUDER_FIRST_CASE) && (799 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (799))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 799),
+#endif
+#endif
+#if     ((800 >= GSL_INCLUDER_FIRST_CASE) && (800 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (800))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 800),
+#endif
+#endif
+#if     ((801 >= GSL_INCLUDER_FIRST_CASE) && (801 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (801))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 801),
+#endif
+#endif
+#if     ((802 >= GSL_INCLUDER_FIRST_CASE) && (802 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (802))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 802),
+#endif
+#endif
+#if     ((803 >= GSL_INCLUDER_FIRST_CASE) && (803 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (803))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 803),
+#endif
+#endif
+#if     ((804 >= GSL_INCLUDER_FIRST_CASE) && (804 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (804))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 804),
+#endif
+#endif
+#if     ((805 >= GSL_INCLUDER_FIRST_CASE) && (805 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (805))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 805),
+#endif
+#endif
+#if     ((806 >= GSL_INCLUDER_FIRST_CASE) && (806 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (806))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 806),
+#endif
+#endif
+#if     ((807 >= GSL_INCLUDER_FIRST_CASE) && (807 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (807))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 807),
+#endif
+#endif
+#if     ((808 >= GSL_INCLUDER_FIRST_CASE) && (808 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (808))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 808),
+#endif
+#endif
+#if     ((809 >= GSL_INCLUDER_FIRST_CASE) && (809 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (809))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 809),
+#endif
+#endif
+#if     ((810 >= GSL_INCLUDER_FIRST_CASE) && (810 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (810))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 810),
+#endif
+#endif
+#if     ((811 >= GSL_INCLUDER_FIRST_CASE) && (811 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (811))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 811),
+#endif
+#endif
+#if     ((812 >= GSL_INCLUDER_FIRST_CASE) && (812 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (812))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 812),
+#endif
+#endif
+#if     ((813 >= GSL_INCLUDER_FIRST_CASE) && (813 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (813))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 813),
+#endif
+#endif
+#if     ((814 >= GSL_INCLUDER_FIRST_CASE) && (814 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (814))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 814),
+#endif
+#endif
+#if     ((815 >= GSL_INCLUDER_FIRST_CASE) && (815 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (815))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 815),
+#endif
+#endif
+#if     ((816 >= GSL_INCLUDER_FIRST_CASE) && (816 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (816))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 816),
+#endif
+#endif
+#if     ((817 >= GSL_INCLUDER_FIRST_CASE) && (817 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (817))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 817),
+#endif
+#endif
+#if     ((818 >= GSL_INCLUDER_FIRST_CASE) && (818 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (818))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 818),
+#endif
+#endif
+#if     ((819 >= GSL_INCLUDER_FIRST_CASE) && (819 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (819))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 819),
+#endif
+#endif
+#if     ((820 >= GSL_INCLUDER_FIRST_CASE) && (820 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (820))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 820),
+#endif
+#endif
+#if     ((821 >= GSL_INCLUDER_FIRST_CASE) && (821 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (821))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 821),
+#endif
+#endif
+#if     ((822 >= GSL_INCLUDER_FIRST_CASE) && (822 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (822))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 822),
+#endif
+#endif
+#if     ((823 >= GSL_INCLUDER_FIRST_CASE) && (823 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (823))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 823),
+#endif
+#endif
+#if     ((824 >= GSL_INCLUDER_FIRST_CASE) && (824 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (824))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 824),
+#endif
+#endif
+#if     ((825 >= GSL_INCLUDER_FIRST_CASE) && (825 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (825))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 825),
+#endif
+#endif
+#if     ((826 >= GSL_INCLUDER_FIRST_CASE) && (826 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (826))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 826),
+#endif
+#endif
+#if     ((827 >= GSL_INCLUDER_FIRST_CASE) && (827 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (827))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 827),
+#endif
+#endif
+#if     ((828 >= GSL_INCLUDER_FIRST_CASE) && (828 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (828))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 828),
+#endif
+#endif
+#if     ((829 >= GSL_INCLUDER_FIRST_CASE) && (829 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (829))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 829),
+#endif
+#endif
+#if     ((830 >= GSL_INCLUDER_FIRST_CASE) && (830 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (830))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 830),
+#endif
+#endif
+#if     ((831 >= GSL_INCLUDER_FIRST_CASE) && (831 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (831))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 831),
+#endif
+#endif
+#if     ((832 >= GSL_INCLUDER_FIRST_CASE) && (832 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (832))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 832),
+#endif
+#endif
+#if     ((833 >= GSL_INCLUDER_FIRST_CASE) && (833 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (833))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 833),
+#endif
+#endif
+#if     ((834 >= GSL_INCLUDER_FIRST_CASE) && (834 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (834))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 834),
+#endif
+#endif
+#if     ((835 >= GSL_INCLUDER_FIRST_CASE) && (835 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (835))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 835),
+#endif
+#endif
+#if     ((836 >= GSL_INCLUDER_FIRST_CASE) && (836 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (836))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 836),
+#endif
+#endif
+#if     ((837 >= GSL_INCLUDER_FIRST_CASE) && (837 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (837))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 837),
+#endif
+#endif
+#if     ((838 >= GSL_INCLUDER_FIRST_CASE) && (838 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (838))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 838),
+#endif
+#endif
+#if     ((839 >= GSL_INCLUDER_FIRST_CASE) && (839 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (839))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 839),
+#endif
+#endif
+#if     ((840 >= GSL_INCLUDER_FIRST_CASE) && (840 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (840))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 840),
+#endif
+#endif
+#if     ((841 >= GSL_INCLUDER_FIRST_CASE) && (841 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (841))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 841),
+#endif
+#endif
+#if     ((842 >= GSL_INCLUDER_FIRST_CASE) && (842 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (842))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 842),
+#endif
+#endif
+#if     ((843 >= GSL_INCLUDER_FIRST_CASE) && (843 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (843))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 843),
+#endif
+#endif
+#if     ((844 >= GSL_INCLUDER_FIRST_CASE) && (844 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (844))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 844),
+#endif
+#endif
+#if     ((845 >= GSL_INCLUDER_FIRST_CASE) && (845 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (845))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 845),
+#endif
+#endif
+#if     ((846 >= GSL_INCLUDER_FIRST_CASE) && (846 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (846))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 846),
+#endif
+#endif
+#if     ((847 >= GSL_INCLUDER_FIRST_CASE) && (847 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (847))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 847),
+#endif
+#endif
+#if     ((848 >= GSL_INCLUDER_FIRST_CASE) && (848 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (848))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 848),
+#endif
+#endif
+#if     ((849 >= GSL_INCLUDER_FIRST_CASE) && (849 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (849))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 849),
+#endif
+#endif
+#if     ((850 >= GSL_INCLUDER_FIRST_CASE) && (850 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (850))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 850),
+#endif
+#endif
+#if     ((851 >= GSL_INCLUDER_FIRST_CASE) && (851 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (851))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 851),
+#endif
+#endif
+#if     ((852 >= GSL_INCLUDER_FIRST_CASE) && (852 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (852))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 852),
+#endif
+#endif
+#if     ((853 >= GSL_INCLUDER_FIRST_CASE) && (853 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (853))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 853),
+#endif
+#endif
+#if     ((854 >= GSL_INCLUDER_FIRST_CASE) && (854 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (854))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 854),
+#endif
+#endif
+#if     ((855 >= GSL_INCLUDER_FIRST_CASE) && (855 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (855))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 855),
+#endif
+#endif
+#if     ((856 >= GSL_INCLUDER_FIRST_CASE) && (856 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (856))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 856),
+#endif
+#endif
+#if     ((857 >= GSL_INCLUDER_FIRST_CASE) && (857 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (857))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 857),
+#endif
+#endif
+#if     ((858 >= GSL_INCLUDER_FIRST_CASE) && (858 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (858))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 858),
+#endif
+#endif
+#if     ((859 >= GSL_INCLUDER_FIRST_CASE) && (859 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (859))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 859),
+#endif
+#endif
+#if     ((860 >= GSL_INCLUDER_FIRST_CASE) && (860 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (860))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 860),
+#endif
+#endif
+#if     ((861 >= GSL_INCLUDER_FIRST_CASE) && (861 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (861))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 861),
+#endif
+#endif
+#if     ((862 >= GSL_INCLUDER_FIRST_CASE) && (862 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (862))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 862),
+#endif
+#endif
+#if     ((863 >= GSL_INCLUDER_FIRST_CASE) && (863 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (863))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 863),
+#endif
+#endif
+#if     ((864 >= GSL_INCLUDER_FIRST_CASE) && (864 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (864))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 864),
+#endif
+#endif
+#if     ((865 >= GSL_INCLUDER_FIRST_CASE) && (865 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (865))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 865),
+#endif
+#endif
+#if     ((866 >= GSL_INCLUDER_FIRST_CASE) && (866 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (866))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 866),
+#endif
+#endif
+#if     ((867 >= GSL_INCLUDER_FIRST_CASE) && (867 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (867))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 867),
+#endif
+#endif
+#if     ((868 >= GSL_INCLUDER_FIRST_CASE) && (868 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (868))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 868),
+#endif
+#endif
+#if     ((869 >= GSL_INCLUDER_FIRST_CASE) && (869 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (869))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 869),
+#endif
+#endif
+#if     ((870 >= GSL_INCLUDER_FIRST_CASE) && (870 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (870))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 870),
+#endif
+#endif
+#if     ((871 >= GSL_INCLUDER_FIRST_CASE) && (871 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (871))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 871),
+#endif
+#endif
+#if     ((872 >= GSL_INCLUDER_FIRST_CASE) && (872 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (872))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 872),
+#endif
+#endif
+#if     ((873 >= GSL_INCLUDER_FIRST_CASE) && (873 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (873))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 873),
+#endif
+#endif
+#if     ((874 >= GSL_INCLUDER_FIRST_CASE) && (874 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (874))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 874),
+#endif
+#endif
+#if     ((875 >= GSL_INCLUDER_FIRST_CASE) && (875 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (875))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 875),
+#endif
+#endif
+#if     ((876 >= GSL_INCLUDER_FIRST_CASE) && (876 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (876))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 876),
+#endif
+#endif
+#if     ((877 >= GSL_INCLUDER_FIRST_CASE) && (877 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (877))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 877),
+#endif
+#endif
+#if     ((878 >= GSL_INCLUDER_FIRST_CASE) && (878 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (878))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 878),
+#endif
+#endif
+#if     ((879 >= GSL_INCLUDER_FIRST_CASE) && (879 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (879))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 879),
+#endif
+#endif
+#if     ((880 >= GSL_INCLUDER_FIRST_CASE) && (880 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (880))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 880),
+#endif
+#endif
+#if     ((881 >= GSL_INCLUDER_FIRST_CASE) && (881 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (881))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 881),
+#endif
+#endif
+#if     ((882 >= GSL_INCLUDER_FIRST_CASE) && (882 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (882))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 882),
+#endif
+#endif
+#if     ((883 >= GSL_INCLUDER_FIRST_CASE) && (883 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (883))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 883),
+#endif
+#endif
+#if     ((884 >= GSL_INCLUDER_FIRST_CASE) && (884 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (884))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 884),
+#endif
+#endif
+#if     ((885 >= GSL_INCLUDER_FIRST_CASE) && (885 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (885))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 885),
+#endif
+#endif
+#if     ((886 >= GSL_INCLUDER_FIRST_CASE) && (886 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (886))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 886),
+#endif
+#endif
+#if     ((887 >= GSL_INCLUDER_FIRST_CASE) && (887 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (887))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 887),
+#endif
+#endif
+#if     ((888 >= GSL_INCLUDER_FIRST_CASE) && (888 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (888))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 888),
+#endif
+#endif
+#if     ((889 >= GSL_INCLUDER_FIRST_CASE) && (889 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (889))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 889),
+#endif
+#endif
+#if     ((890 >= GSL_INCLUDER_FIRST_CASE) && (890 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (890))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 890),
+#endif
+#endif
+#if     ((891 >= GSL_INCLUDER_FIRST_CASE) && (891 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (891))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 891),
+#endif
+#endif
+#if     ((892 >= GSL_INCLUDER_FIRST_CASE) && (892 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (892))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 892),
+#endif
+#endif
+#if     ((893 >= GSL_INCLUDER_FIRST_CASE) && (893 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (893))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 893),
+#endif
+#endif
+#if     ((894 >= GSL_INCLUDER_FIRST_CASE) && (894 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (894))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 894),
+#endif
+#endif
+#if     ((895 >= GSL_INCLUDER_FIRST_CASE) && (895 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (895))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 895),
+#endif
+#endif
+#if     ((896 >= GSL_INCLUDER_FIRST_CASE) && (896 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (896))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 896),
+#endif
+#endif
+#if     ((897 >= GSL_INCLUDER_FIRST_CASE) && (897 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (897))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 897),
+#endif
+#endif
+#if     ((898 >= GSL_INCLUDER_FIRST_CASE) && (898 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (898))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 898),
+#endif
+#endif
+#if     ((899 >= GSL_INCLUDER_FIRST_CASE) && (899 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (899))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 899),
+#endif
+#endif
+#if     ((900 >= GSL_INCLUDER_FIRST_CASE) && (900 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (900))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 900),
+#endif
+#endif
+#if     ((901 >= GSL_INCLUDER_FIRST_CASE) && (901 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (901))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 901),
+#endif
+#endif
+#if     ((902 >= GSL_INCLUDER_FIRST_CASE) && (902 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (902))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 902),
+#endif
+#endif
+#if     ((903 >= GSL_INCLUDER_FIRST_CASE) && (903 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (903))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 903),
+#endif
+#endif
+#if     ((904 >= GSL_INCLUDER_FIRST_CASE) && (904 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (904))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 904),
+#endif
+#endif
+#if     ((905 >= GSL_INCLUDER_FIRST_CASE) && (905 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (905))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 905),
+#endif
+#endif
+#if     ((906 >= GSL_INCLUDER_FIRST_CASE) && (906 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (906))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 906),
+#endif
+#endif
+#if     ((907 >= GSL_INCLUDER_FIRST_CASE) && (907 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (907))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 907),
+#endif
+#endif
+#if     ((908 >= GSL_INCLUDER_FIRST_CASE) && (908 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (908))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 908),
+#endif
+#endif
+#if     ((909 >= GSL_INCLUDER_FIRST_CASE) && (909 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (909))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 909),
+#endif
+#endif
+#if     ((910 >= GSL_INCLUDER_FIRST_CASE) && (910 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (910))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 910),
+#endif
+#endif
+#if     ((911 >= GSL_INCLUDER_FIRST_CASE) && (911 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (911))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 911),
+#endif
+#endif
+#if     ((912 >= GSL_INCLUDER_FIRST_CASE) && (912 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (912))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 912),
+#endif
+#endif
+#if     ((913 >= GSL_INCLUDER_FIRST_CASE) && (913 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (913))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 913),
+#endif
+#endif
+#if     ((914 >= GSL_INCLUDER_FIRST_CASE) && (914 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (914))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 914),
+#endif
+#endif
+#if     ((915 >= GSL_INCLUDER_FIRST_CASE) && (915 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (915))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 915),
+#endif
+#endif
+#if     ((916 >= GSL_INCLUDER_FIRST_CASE) && (916 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (916))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 916),
+#endif
+#endif
+#if     ((917 >= GSL_INCLUDER_FIRST_CASE) && (917 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (917))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 917),
+#endif
+#endif
+#if     ((918 >= GSL_INCLUDER_FIRST_CASE) && (918 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (918))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 918),
+#endif
+#endif
+#if     ((919 >= GSL_INCLUDER_FIRST_CASE) && (919 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (919))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 919),
+#endif
+#endif
+#if     ((920 >= GSL_INCLUDER_FIRST_CASE) && (920 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (920))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 920),
+#endif
+#endif
+#if     ((921 >= GSL_INCLUDER_FIRST_CASE) && (921 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (921))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 921),
+#endif
+#endif
+#if     ((922 >= GSL_INCLUDER_FIRST_CASE) && (922 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (922))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 922),
+#endif
+#endif
+#if     ((923 >= GSL_INCLUDER_FIRST_CASE) && (923 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (923))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 923),
+#endif
+#endif
+#if     ((924 >= GSL_INCLUDER_FIRST_CASE) && (924 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (924))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 924),
+#endif
+#endif
+#if     ((925 >= GSL_INCLUDER_FIRST_CASE) && (925 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (925))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 925),
+#endif
+#endif
+#if     ((926 >= GSL_INCLUDER_FIRST_CASE) && (926 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (926))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 926),
+#endif
+#endif
+#if     ((927 >= GSL_INCLUDER_FIRST_CASE) && (927 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (927))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 927),
+#endif
+#endif
+#if     ((928 >= GSL_INCLUDER_FIRST_CASE) && (928 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (928))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 928),
+#endif
+#endif
+#if     ((929 >= GSL_INCLUDER_FIRST_CASE) && (929 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (929))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 929),
+#endif
+#endif
+#if     ((930 >= GSL_INCLUDER_FIRST_CASE) && (930 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (930))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 930),
+#endif
+#endif
+#if     ((931 >= GSL_INCLUDER_FIRST_CASE) && (931 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (931))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 931),
+#endif
+#endif
+#if     ((932 >= GSL_INCLUDER_FIRST_CASE) && (932 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (932))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 932),
+#endif
+#endif
+#if     ((933 >= GSL_INCLUDER_FIRST_CASE) && (933 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (933))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 933),
+#endif
+#endif
+#if     ((934 >= GSL_INCLUDER_FIRST_CASE) && (934 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (934))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 934),
+#endif
+#endif
+#if     ((935 >= GSL_INCLUDER_FIRST_CASE) && (935 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (935))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 935),
+#endif
+#endif
+#if     ((936 >= GSL_INCLUDER_FIRST_CASE) && (936 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (936))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 936),
+#endif
+#endif
+#if     ((937 >= GSL_INCLUDER_FIRST_CASE) && (937 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (937))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 937),
+#endif
+#endif
+#if     ((938 >= GSL_INCLUDER_FIRST_CASE) && (938 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (938))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 938),
+#endif
+#endif
+#if     ((939 >= GSL_INCLUDER_FIRST_CASE) && (939 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (939))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 939),
+#endif
+#endif
+#if     ((940 >= GSL_INCLUDER_FIRST_CASE) && (940 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (940))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 940),
+#endif
+#endif
+#if     ((941 >= GSL_INCLUDER_FIRST_CASE) && (941 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (941))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 941),
+#endif
+#endif
+#if     ((942 >= GSL_INCLUDER_FIRST_CASE) && (942 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (942))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 942),
+#endif
+#endif
+#if     ((943 >= GSL_INCLUDER_FIRST_CASE) && (943 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (943))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 943),
+#endif
+#endif
+#if     ((944 >= GSL_INCLUDER_FIRST_CASE) && (944 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (944))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 944),
+#endif
+#endif
+#if     ((945 >= GSL_INCLUDER_FIRST_CASE) && (945 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (945))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 945),
+#endif
+#endif
+#if     ((946 >= GSL_INCLUDER_FIRST_CASE) && (946 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (946))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 946),
+#endif
+#endif
+#if     ((947 >= GSL_INCLUDER_FIRST_CASE) && (947 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (947))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 947),
+#endif
+#endif
+#if     ((948 >= GSL_INCLUDER_FIRST_CASE) && (948 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (948))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 948),
+#endif
+#endif
+#if     ((949 >= GSL_INCLUDER_FIRST_CASE) && (949 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (949))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 949),
+#endif
+#endif
+#if     ((950 >= GSL_INCLUDER_FIRST_CASE) && (950 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (950))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 950),
+#endif
+#endif
+#if     ((951 >= GSL_INCLUDER_FIRST_CASE) && (951 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (951))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 951),
+#endif
+#endif
+#if     ((952 >= GSL_INCLUDER_FIRST_CASE) && (952 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (952))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 952),
+#endif
+#endif
+#if     ((953 >= GSL_INCLUDER_FIRST_CASE) && (953 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (953))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 953),
+#endif
+#endif
+#if     ((954 >= GSL_INCLUDER_FIRST_CASE) && (954 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (954))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 954),
+#endif
+#endif
+#if     ((955 >= GSL_INCLUDER_FIRST_CASE) && (955 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (955))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 955),
+#endif
+#endif
+#if     ((956 >= GSL_INCLUDER_FIRST_CASE) && (956 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (956))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 956),
+#endif
+#endif
+#if     ((957 >= GSL_INCLUDER_FIRST_CASE) && (957 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (957))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 957),
+#endif
+#endif
+#if     ((958 >= GSL_INCLUDER_FIRST_CASE) && (958 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (958))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 958),
+#endif
+#endif
+#if     ((959 >= GSL_INCLUDER_FIRST_CASE) && (959 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (959))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 959),
+#endif
+#endif
+#if     ((960 >= GSL_INCLUDER_FIRST_CASE) && (960 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (960))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 960),
+#endif
+#endif
+#if     ((961 >= GSL_INCLUDER_FIRST_CASE) && (961 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (961))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 961),
+#endif
+#endif
+#if     ((962 >= GSL_INCLUDER_FIRST_CASE) && (962 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (962))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 962),
+#endif
+#endif
+#if     ((963 >= GSL_INCLUDER_FIRST_CASE) && (963 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (963))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 963),
+#endif
+#endif
+#if     ((964 >= GSL_INCLUDER_FIRST_CASE) && (964 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (964))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 964),
+#endif
+#endif
+#if     ((965 >= GSL_INCLUDER_FIRST_CASE) && (965 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (965))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 965),
+#endif
+#endif
+#if     ((966 >= GSL_INCLUDER_FIRST_CASE) && (966 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (966))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 966),
+#endif
+#endif
+#if     ((967 >= GSL_INCLUDER_FIRST_CASE) && (967 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (967))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 967),
+#endif
+#endif
+#if     ((968 >= GSL_INCLUDER_FIRST_CASE) && (968 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (968))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 968),
+#endif
+#endif
+#if     ((969 >= GSL_INCLUDER_FIRST_CASE) && (969 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (969))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 969),
+#endif
+#endif
+#if     ((970 >= GSL_INCLUDER_FIRST_CASE) && (970 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (970))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 970),
+#endif
+#endif
+#if     ((971 >= GSL_INCLUDER_FIRST_CASE) && (971 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (971))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 971),
+#endif
+#endif
+#if     ((972 >= GSL_INCLUDER_FIRST_CASE) && (972 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (972))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 972),
+#endif
+#endif
+#if     ((973 >= GSL_INCLUDER_FIRST_CASE) && (973 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (973))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 973),
+#endif
+#endif
+#if     ((974 >= GSL_INCLUDER_FIRST_CASE) && (974 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (974))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 974),
+#endif
+#endif
+#if     ((975 >= GSL_INCLUDER_FIRST_CASE) && (975 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (975))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 975),
+#endif
+#endif
+#if     ((976 >= GSL_INCLUDER_FIRST_CASE) && (976 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (976))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 976),
+#endif
+#endif
+#if     ((977 >= GSL_INCLUDER_FIRST_CASE) && (977 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (977))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 977),
+#endif
+#endif
+#if     ((978 >= GSL_INCLUDER_FIRST_CASE) && (978 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (978))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 978),
+#endif
+#endif
+#if     ((979 >= GSL_INCLUDER_FIRST_CASE) && (979 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (979))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 979),
+#endif
+#endif
+#if     ((980 >= GSL_INCLUDER_FIRST_CASE) && (980 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (980))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 980),
+#endif
+#endif
+#if     ((981 >= GSL_INCLUDER_FIRST_CASE) && (981 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (981))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 981),
+#endif
+#endif
+#if     ((982 >= GSL_INCLUDER_FIRST_CASE) && (982 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (982))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 982),
+#endif
+#endif
+#if     ((983 >= GSL_INCLUDER_FIRST_CASE) && (983 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (983))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 983),
+#endif
+#endif
+#if     ((984 >= GSL_INCLUDER_FIRST_CASE) && (984 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (984))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 984),
+#endif
+#endif
+#if     ((985 >= GSL_INCLUDER_FIRST_CASE) && (985 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (985))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 985),
+#endif
+#endif
+#if     ((986 >= GSL_INCLUDER_FIRST_CASE) && (986 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (986))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 986),
+#endif
+#endif
+#if     ((987 >= GSL_INCLUDER_FIRST_CASE) && (987 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (987))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 987),
+#endif
+#endif
+#if     ((988 >= GSL_INCLUDER_FIRST_CASE) && (988 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (988))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 988),
+#endif
+#endif
+#if     ((989 >= GSL_INCLUDER_FIRST_CASE) && (989 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (989))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 989),
+#endif
+#endif
+#if     ((990 >= GSL_INCLUDER_FIRST_CASE) && (990 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (990))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 990),
+#endif
+#endif
+#if     ((991 >= GSL_INCLUDER_FIRST_CASE) && (991 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (991))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 991),
+#endif
+#endif
+#if     ((992 >= GSL_INCLUDER_FIRST_CASE) && (992 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (992))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 992),
+#endif
+#endif
+#if     ((993 >= GSL_INCLUDER_FIRST_CASE) && (993 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (993))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 993),
+#endif
+#endif
+#if     ((994 >= GSL_INCLUDER_FIRST_CASE) && (994 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (994))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 994),
+#endif
+#endif
+#if     ((995 >= GSL_INCLUDER_FIRST_CASE) && (995 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (995))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 995),
+#endif
+#endif
+#if     ((996 >= GSL_INCLUDER_FIRST_CASE) && (996 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (996))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 996),
+#endif
+#endif
+#if     ((997 >= GSL_INCLUDER_FIRST_CASE) && (997 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (997))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 997),
+#endif
+#endif
+#if     ((998 >= GSL_INCLUDER_FIRST_CASE) && (998 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (998))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 998),
+#endif
+#endif
+#if     ((999 >= GSL_INCLUDER_FIRST_CASE) && (999 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (999))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 999),
+#endif
+#endif
+#if     ((1000 >= GSL_INCLUDER_FIRST_CASE) && (1000 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1000))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1000),
+#endif
+#endif
+#if     ((1001 >= GSL_INCLUDER_FIRST_CASE) && (1001 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1001))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1001),
+#endif
+#endif
+#if     ((1002 >= GSL_INCLUDER_FIRST_CASE) && (1002 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1002))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1002),
+#endif
+#endif
+#if     ((1003 >= GSL_INCLUDER_FIRST_CASE) && (1003 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1003))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1003),
+#endif
+#endif
+#if     ((1004 >= GSL_INCLUDER_FIRST_CASE) && (1004 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1004))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1004),
+#endif
+#endif
+#if     ((1005 >= GSL_INCLUDER_FIRST_CASE) && (1005 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1005))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1005),
+#endif
+#endif
+#if     ((1006 >= GSL_INCLUDER_FIRST_CASE) && (1006 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1006))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1006),
+#endif
+#endif
+#if     ((1007 >= GSL_INCLUDER_FIRST_CASE) && (1007 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1007))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1007),
+#endif
+#endif
+#if     ((1008 >= GSL_INCLUDER_FIRST_CASE) && (1008 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1008))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1008),
+#endif
+#endif
+#if     ((1009 >= GSL_INCLUDER_FIRST_CASE) && (1009 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1009))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1009),
+#endif
+#endif
+#if     ((1010 >= GSL_INCLUDER_FIRST_CASE) && (1010 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1010))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1010),
+#endif
+#endif
+#if     ((1011 >= GSL_INCLUDER_FIRST_CASE) && (1011 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1011))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1011),
+#endif
+#endif
+#if     ((1012 >= GSL_INCLUDER_FIRST_CASE) && (1012 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1012))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1012),
+#endif
+#endif
+#if     ((1013 >= GSL_INCLUDER_FIRST_CASE) && (1013 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1013))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1013),
+#endif
+#endif
+#if     ((1014 >= GSL_INCLUDER_FIRST_CASE) && (1014 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1014))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1014),
+#endif
+#endif
+#if     ((1015 >= GSL_INCLUDER_FIRST_CASE) && (1015 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1015))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1015),
+#endif
+#endif
+#if     ((1016 >= GSL_INCLUDER_FIRST_CASE) && (1016 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1016))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1016),
+#endif
+#endif
+#if     ((1017 >= GSL_INCLUDER_FIRST_CASE) && (1017 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1017))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1017),
+#endif
+#endif
+#if     ((1018 >= GSL_INCLUDER_FIRST_CASE) && (1018 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1018))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1018),
+#endif
+#endif
+#if     ((1019 >= GSL_INCLUDER_FIRST_CASE) && (1019 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1019))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1019),
+#endif
+#endif
+#if     ((1020 >= GSL_INCLUDER_FIRST_CASE) && (1020 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1020))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1020),
+#endif
+#endif
+#if     ((1021 >= GSL_INCLUDER_FIRST_CASE) && (1021 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1021))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1021),
+#endif
+#endif
+#if     ((1022 >= GSL_INCLUDER_FIRST_CASE) && (1022 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1022))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1022),
+#endif
+#endif
+#if     ((1023 >= GSL_INCLUDER_FIRST_CASE) && (1023 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1023))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1023),
+#endif
+#endif
+#if     ((1024 >= GSL_INCLUDER_FIRST_CASE) && (1024 <= GSL_INCLUDER_LAST_CASE))
+#if     (GSL_INCLUDER_REJECT (1024))
+  NULL,
+#else
+  GSL_INCLUDER_MAKE_FUNC (GSL_INCLUDER_NAME, 1024),
+#endif
+#endif
+};
+
+#undef GSL_INCLUDER_REJECT
+#undef GSL_INCLUDER_FUNC
+#undef GSL_INCLUDER_CONCAT3
+#undef GSL_INCLUDER_MAKE_FUNC
+#undef GSL_INCLUDER_FIRST_CASE
+#undef GSL_INCLUDER_LAST_CASE
+#undef GSL_INCLUDER_NAME
+#undef GSL_INCLUDER_TABLE
+#undef GSL_INCLUDER_FILE
diff --git a/flow/gsl/gslloader-gslwave.c b/flow/gsl/gslloader-gslwave.c
new file mode 100644
index 0000000..e851a12
--- /dev/null
+++ b/flow/gsl/gslloader-gslwave.c
@@ -0,0 +1,701 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001, 2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslloader.h"
+
+#include "gsldatahandle.h"
+#include "gslmath.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+
+#define	GSL_DEBUG_LOADER	g_message
+
+#define parse_or_return(scanner, token) { guint _t = (token); \
+                                          if (g_scanner_get_next_token (scanner) != _t) \
+                                            return _t; \
+                                        }
+
+
+/* --- token types --- */
+typedef enum
+{
+  /* wave tokens */
+  GSL_WAVE_TOKEN_WAVE           = 512,
+  GSL_WAVE_TOKEN_CHUNK,
+  GSL_WAVE_TOKEN_NAME,
+  GSL_WAVE_TOKEN_BYTE_ORDER,
+  GSL_WAVE_TOKEN_FORMAT,
+  GSL_WAVE_TOKEN_N_CHANNELS,
+  GSL_WAVE_TOKEN_MIX_FREQ,
+  GSL_WAVE_TOKEN_OSC_FREQ,
+  GSL_WAVE_TOKEN_MIDI_NOTE,
+  GSL_WAVE_TOKEN_FILE,
+  GSL_WAVE_TOKEN_INDEX,
+  GSL_WAVE_TOKEN_BOFFSET,
+  GSL_WAVE_TOKEN_N_VALUES,
+  GSL_WAVE_TOKEN_LOOP_TYPE,
+  GSL_WAVE_TOKEN_LOOP_START,
+  GSL_WAVE_TOKEN_LOOP_END,
+  GSL_WAVE_TOKEN_LOOP_COUNT,
+  GSL_WAVE_TOKEN_LAST_FIELD,
+  /* data tokens */
+  GSL_WAVE_TOKEN_BIG_ENDIAN     = 768,
+  GSL_WAVE_TOKEN_BIG,
+  GSL_WAVE_TOKEN_LITTLE_ENDIAN,
+  GSL_WAVE_TOKEN_LITTLE,
+  GSL_WAVE_TOKEN_SIGNED_8,
+  GSL_WAVE_TOKEN_SIGNED_12,
+  GSL_WAVE_TOKEN_SIGNED_16,
+  GSL_WAVE_TOKEN_UNSIGNED_8,
+  GSL_WAVE_TOKEN_UNSIGNED_12,
+  GSL_WAVE_TOKEN_UNSIGNED_16,
+  GSL_WAVE_TOKEN_FLOAT,
+  GSL_WAVE_TOKEN_NONE,
+  GSL_WAVE_TOKEN_JUMP,
+  GSL_WAVE_TOKEN_PINGPONG,
+  GSL_WAVE_TOKEN_LAST_DATA
+} GslWaveTokenType;
+
+
+/* --- structures --- */
+typedef struct
+{
+  GslWaveFileInfo wfi;
+  gchar          *cwd;
+} FileInfo;
+
+typedef struct
+{
+  GslWaveDsc        wdsc;
+  GslWaveFormatType format;
+  guint		    byte_order;
+  gfloat	    dfl_mix_freq;
+} WaveDsc;
+
+
+/* --- tokens --- */
+static const char *wave_tokens_512[] = {
+  "wave",       "chunk",        "name",         "byte_order",
+  "format",     "n_channels",   "mix_freq",     "osc_freq",
+  "midi_note",  "file",         "index",	"boffset",
+  "n_values",	"loop_type",	"loop_start",	"loop_end",
+  "loop_count",
+};
+static const char *wave_tokens_768[] = {
+  "big_endian", "big",          "little_endian", "little",
+  "signed_8",   "signed_12",    "signed_16",
+  "unsigned_8", "unsigned_12",  "unsigned_16",
+  "float",	"none",		"jump",		 "pingpong",
+};
+
+
+/* --- functions --- */
+static const gchar*
+gsl_wave_token (GslWaveTokenType token)
+{
+  if (token >= 768)
+    {
+      token -= 768;
+      return token > sizeof (wave_tokens_768) / sizeof (wave_tokens_768[0]) ? NULL : wave_tokens_768[token];
+    }
+  else
+    {
+      token -= 512;
+      return token > sizeof (wave_tokens_512) / sizeof (wave_tokens_512[0]) ? NULL : wave_tokens_512[token];
+    }
+}
+
+static GTokenType
+gslwave_skip_rest_statement (GScanner *scanner,
+			     guint     level)
+{
+  g_return_val_if_fail (scanner != NULL, G_TOKEN_ERROR);
+
+  while (level)
+    {
+      g_scanner_get_next_token (scanner);
+      switch (scanner->token)
+	{
+	case G_TOKEN_EOF: case G_TOKEN_ERROR:                   return '}';
+	case '(': case '{': case '[':           level++;        break;
+	case ')': case '}': case ']':           level--;        break;
+	default:                                                break;
+	}
+    }
+
+  return G_TOKEN_NONE;
+}
+
+static GslWaveFileInfo*
+gslwave_load_file_info (gpointer      data,
+			const gchar  *_file_name,
+			GslErrorType *error_p)
+{
+  FileInfo *fi = NULL;
+  gboolean in_wave = FALSE, abort = FALSE;
+  GslRing *wave_names = NULL;
+  GScanner *scanner;
+  gchar *cwd, *file_name;
+  gint fd;
+  guint i;
+
+  if (g_path_is_absolute (_file_name))
+    {
+      gchar *p = strrchr (_file_name, G_DIR_SEPARATOR);
+
+      g_assert (p != NULL);
+      cwd = g_strndup (_file_name, p - _file_name + 1);
+      file_name = g_strdup (_file_name);
+    }
+  else
+    {
+      cwd = g_get_current_dir ();
+      file_name = g_strdup_printf ("%s%c%s", cwd, G_DIR_SEPARATOR, _file_name);
+    }
+
+  fd = open (file_name, O_RDONLY);
+  if (fd < 0)
+    {
+      *error_p = GSL_ERROR_OPEN_FAILED;
+      g_free (cwd);
+      g_free (file_name);
+      return NULL;
+    }
+
+  scanner = g_scanner_new (NULL);
+  scanner->config->symbol_2_token = TRUE;
+  g_scanner_scope_add_symbol (scanner, 0, "wave", GUINT_TO_POINTER (GSL_WAVE_TOKEN_WAVE));
+  g_scanner_scope_add_symbol (scanner, 0, "name", GUINT_TO_POINTER (GSL_WAVE_TOKEN_NAME));
+  g_scanner_input_file (scanner, fd);
+  while (!abort)
+    {
+      g_scanner_get_next_token (scanner);
+      switch (scanner->token)
+	{
+	case GSL_WAVE_TOKEN_WAVE:
+	  if (g_scanner_peek_next_token (scanner) == '{')
+	    {
+	      g_scanner_get_next_token (scanner); /* eat '{' */
+	      in_wave = TRUE;
+	    }
+	  break;
+	case '{':
+	  if (gslwave_skip_rest_statement (scanner, 1) != G_TOKEN_NONE)
+	    abort = TRUE;
+	  break;
+	case GSL_WAVE_TOKEN_NAME:
+	  if (in_wave && g_scanner_peek_next_token (scanner) == '=')
+	    {
+	      g_scanner_get_next_token (scanner); /* eat '=' */
+	      if (g_scanner_peek_next_token (scanner) == G_TOKEN_STRING)
+		{
+		  gchar *wave_name;
+		  
+		  g_scanner_get_next_token (scanner); /* eat string */
+		  wave_name = g_strdup (scanner->value.v_string);
+		  if (gslwave_skip_rest_statement (scanner, 1) == G_TOKEN_NONE)
+		    {
+		      in_wave = FALSE;
+		      wave_names = gsl_ring_append (wave_names, wave_name);
+		    }
+		  else
+		    {
+		      g_free (wave_name);
+		      abort = TRUE;
+		    }
+		}
+	    }
+	  break;
+	default:
+	  if (scanner->token == G_TOKEN_EOF || scanner->token == G_TOKEN_ERROR)
+	    abort = TRUE;
+	  break;
+	}
+    }
+  g_scanner_destroy (scanner);
+  close (fd);
+
+  if (wave_names)
+    {
+      GslRing *ring;
+
+      fi = gsl_new_struct0 (FileInfo, 1);
+      fi->wfi.n_waves = gsl_ring_length (wave_names);
+      fi->wfi.waves = g_malloc0 (sizeof (fi->wfi.waves[0]) * fi->wfi.n_waves);
+      for (i = 0, ring = wave_names; i < fi->wfi.n_waves; i++, ring = ring->next)
+	fi->wfi.waves[i].name = ring->data;
+      gsl_ring_free (wave_names);
+      fi->cwd = cwd;
+    }
+  else
+    g_free (cwd);
+  g_free (file_name);
+
+  /* FIXME: empty wave error? */
+
+  return fi ? &fi->wfi : NULL;
+}
+
+static void
+gslwave_free_file_info (gpointer         data,
+			GslWaveFileInfo *file_info)
+{
+  FileInfo *fi = (FileInfo*) file_info;
+  guint i;
+
+  for (i = 0; i < fi->wfi.n_waves; i++)
+    g_free (fi->wfi.waves[i].name);
+  g_free (fi->wfi.waves);
+  g_free (fi->cwd);
+  gsl_delete_struct (FileInfo, fi);
+}
+
+static guint
+gslwave_parse_chunk_dsc (GScanner        *scanner,
+			 GslWaveChunkDsc *chunk)
+{
+  parse_or_return (scanner, '{');
+  do
+    switch (g_scanner_get_next_token (scanner))
+      {
+      case '}':
+	return G_TOKEN_NONE;
+      default:
+	return '}';
+      case GSL_WAVE_TOKEN_FILE:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_STRING);
+	g_free (chunk->loader_data1);	/* file_name */
+	chunk->loader_data1 = g_strdup (scanner->value.v_string);
+	break;
+      case GSL_WAVE_TOKEN_INDEX:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_STRING);
+	g_free (chunk->loader_data2);	/* wave_name */
+	chunk->loader_data2 = g_strdup (scanner->value.v_string);
+	break;
+      case GSL_WAVE_TOKEN_MIX_FREQ:
+	parse_or_return (scanner, '=');
+	switch (g_scanner_get_next_token (scanner))
+	  {
+	  case G_TOKEN_FLOAT:	chunk->mix_freq = scanner->value.v_float;	break;
+	  case G_TOKEN_INT:	chunk->mix_freq = scanner->value.v_int;		break;
+	  default:		return G_TOKEN_FLOAT;
+	  }
+	break;
+      case GSL_WAVE_TOKEN_OSC_FREQ:
+	parse_or_return (scanner, '=');
+	switch (g_scanner_get_next_token (scanner))
+	  {
+	  case G_TOKEN_FLOAT:	chunk->osc_freq = scanner->value.v_float;	break;
+	  case G_TOKEN_INT:	chunk->osc_freq = scanner->value.v_int;		break;
+	  default:		return G_TOKEN_FLOAT;
+	  }
+	break;
+      case GSL_WAVE_TOKEN_MIDI_NOTE:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_INT);
+	chunk->osc_freq = gsl_temp_freq (gsl_get_config ()->kammer_freq,
+					 scanner->value.v_int - gsl_get_config ()->midi_kammer_note);
+	break;
+      case GSL_WAVE_TOKEN_BOFFSET:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_INT);
+	chunk->loader_offset = scanner->value.v_int;	/* byte_offset */
+	break;
+      case GSL_WAVE_TOKEN_N_VALUES:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_INT);
+	chunk->loader_length = scanner->value.v_int;	/* n_values */
+	break;
+      case GSL_WAVE_TOKEN_LOOP_TYPE:
+	parse_or_return (scanner, '=');
+	switch (g_scanner_get_next_token (scanner))
+	  {
+	  case GSL_WAVE_TOKEN_NONE:	chunk->loop_type = GSL_WAVE_LOOP_NONE;		break;
+	  case GSL_WAVE_TOKEN_JUMP:	chunk->loop_type = GSL_WAVE_LOOP_JUMP;		break;
+	  case GSL_WAVE_TOKEN_PINGPONG:	chunk->loop_type = GSL_WAVE_LOOP_PINGPONG;	break;
+	  default:			return GSL_WAVE_TOKEN_JUMP;
+	  }
+	break;
+      case GSL_WAVE_TOKEN_LOOP_START:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_INT);
+	chunk->loop_start = scanner->value.v_int;
+	break;
+      case GSL_WAVE_TOKEN_LOOP_END:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_INT);
+	chunk->loop_end = scanner->value.v_int;
+	break;
+      case GSL_WAVE_TOKEN_LOOP_COUNT:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_INT);
+	chunk->loop_count = scanner->value.v_int;
+	break;
+      }
+  while (TRUE);
+}
+
+static guint
+gslwave_parse_wave_dsc (GScanner    *scanner,
+			WaveDsc     *dsc,
+			const gchar *wave_name)
+{
+  parse_or_return (scanner, '{');
+  do
+    switch (g_scanner_get_next_token (scanner))
+      {
+	guint i, token;
+      case '}':
+	return G_TOKEN_NONE;
+      default:
+	return '}';
+      case GSL_WAVE_TOKEN_NAME:
+	if (dsc->wdsc.name)
+	  return '}';
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_STRING);
+	if (wave_name)
+	  {
+	    if (strcmp (wave_name, scanner->value.v_string) == 0)
+	      dsc->wdsc.name = g_strdup (scanner->value.v_string);
+	    else
+	      return gslwave_skip_rest_statement (scanner, 1);
+	  }
+	else
+	  dsc->wdsc.name = g_strdup (scanner->value.v_string);
+	break;
+      case GSL_WAVE_TOKEN_CHUNK:
+	if (g_scanner_peek_next_token (scanner) != '{')
+	  parse_or_return (scanner, '{');
+	i = dsc->wdsc.n_chunks++;
+	dsc->wdsc.chunks = g_realloc (dsc->wdsc.chunks, sizeof (dsc->wdsc.chunks[0]) * dsc->wdsc.n_chunks);
+	memset (dsc->wdsc.chunks + i, 0, sizeof (dsc->wdsc.chunks[0]) * 1);
+	dsc->wdsc.chunks[i].mix_freq = dsc->dfl_mix_freq;
+	dsc->wdsc.chunks[i].osc_freq = dsc->dfl_mix_freq;	/* we check this later */
+	dsc->wdsc.chunks[i].loop_type = GSL_WAVE_LOOP_JUMP;
+	dsc->wdsc.chunks[i].loop_start = GSL_MAXLONG;
+	dsc->wdsc.chunks[i].loop_end = -1;
+	dsc->wdsc.chunks[i].loop_count = 1000000; /* FIXME */
+	dsc->wdsc.chunks[i].loader_offset = 0;			/* offset in bytes */
+	dsc->wdsc.chunks[i].loader_length = 0;			/* length in n_values */
+	dsc->wdsc.chunks[i].loader_data1 = NULL;		/* file_name */
+	dsc->wdsc.chunks[i].loader_data2 = NULL;		/* wave_name */
+	token = gslwave_parse_chunk_dsc (scanner, dsc->wdsc.chunks + i);
+	if (token != G_TOKEN_NONE)
+	  return token;
+	if (dsc->wdsc.chunks[i].loop_end < dsc->wdsc.chunks[i].loop_start)
+	  {
+	    dsc->wdsc.chunks[i].loop_type = GSL_WAVE_LOOP_NONE;
+	    dsc->wdsc.chunks[i].loop_start = 0;
+	    dsc->wdsc.chunks[i].loop_end = 0;
+	    dsc->wdsc.chunks[i].loop_count = 0;
+	  }
+	if (dsc->wdsc.chunks[i].osc_freq >= dsc->wdsc.chunks[i].mix_freq / 2.)
+	  g_scanner_error (scanner, "wave chunk \"%s\" mixing frequency is invalid: mix_freq=%f osc_freq=%f",
+			   dsc->wdsc.chunks[i].loader_data1 ? (gchar*) dsc->wdsc.chunks[i].loader_data1 : "",
+			   dsc->wdsc.chunks[i].mix_freq,
+			   dsc->wdsc.chunks[i].osc_freq);
+	break;
+      case GSL_WAVE_TOKEN_BYTE_ORDER:
+	parse_or_return (scanner, '=');
+	token = g_scanner_get_next_token (scanner);
+	switch (token)
+	  {
+	  case GSL_WAVE_TOKEN_LITTLE_ENDIAN:
+	  case GSL_WAVE_TOKEN_LITTLE:		dsc->byte_order = G_LITTLE_ENDIAN; break;
+	  case GSL_WAVE_TOKEN_BIG_ENDIAN:
+	  case GSL_WAVE_TOKEN_BIG:		dsc->byte_order = G_BIG_ENDIAN;    break;
+	  default:				return GSL_WAVE_TOKEN_LITTLE_ENDIAN;
+	  }
+	break;
+      case GSL_WAVE_TOKEN_FORMAT:
+	parse_or_return (scanner, '=');
+	token = g_scanner_get_next_token (scanner);
+	switch (token)
+	  {
+	  case GSL_WAVE_TOKEN_SIGNED_8:		dsc->format = GSL_WAVE_FORMAT_SIGNED_8;    break;
+	  case GSL_WAVE_TOKEN_SIGNED_12:	dsc->format = GSL_WAVE_FORMAT_SIGNED_12;   break;
+	  case GSL_WAVE_TOKEN_SIGNED_16:	dsc->format = GSL_WAVE_FORMAT_SIGNED_16;   break;
+	  case GSL_WAVE_TOKEN_UNSIGNED_8:	dsc->format = GSL_WAVE_FORMAT_UNSIGNED_8;  break;
+	  case GSL_WAVE_TOKEN_UNSIGNED_12:	dsc->format = GSL_WAVE_FORMAT_UNSIGNED_12; break;
+	  case GSL_WAVE_TOKEN_UNSIGNED_16:	dsc->format = GSL_WAVE_FORMAT_UNSIGNED_16; break;
+	  case GSL_WAVE_TOKEN_FLOAT:		dsc->format = GSL_WAVE_FORMAT_FLOAT;	   break;
+	  default:				return GSL_WAVE_TOKEN_SIGNED_16;
+	  }
+	break;
+      case GSL_WAVE_TOKEN_N_CHANNELS:
+	parse_or_return (scanner, '=');
+	parse_or_return (scanner, G_TOKEN_INT);
+	dsc->wdsc.n_channels = scanner->value.v_int;
+	if (dsc->wdsc.n_channels < 1)
+	  return G_TOKEN_INT;
+	break;
+      case GSL_WAVE_TOKEN_MIX_FREQ:
+	parse_or_return (scanner, '=');
+	switch (g_scanner_get_next_token (scanner))
+	  {
+	  case G_TOKEN_FLOAT:   dsc->dfl_mix_freq = scanner->value.v_float;    break;
+	  case G_TOKEN_INT:     dsc->dfl_mix_freq = scanner->value.v_int;      break;
+	  default:		return G_TOKEN_FLOAT;
+	  }
+	break;
+      }
+  while (TRUE);
+}
+
+static void
+gslwave_wave_dsc_free (WaveDsc *dsc)
+{
+  guint i;
+
+  for (i = 0; i < dsc->wdsc.n_chunks; i++)
+    {
+      g_free (dsc->wdsc.chunks[i].loader_data1); /* file_name */
+      g_free (dsc->wdsc.chunks[i].loader_data2); /* wave_name */
+    }
+  g_free (dsc->wdsc.chunks);
+  g_free (dsc->wdsc.name);
+  gsl_delete_struct (WaveDsc, dsc);
+}
+
+static GslWaveDsc*
+gslwave_load_wave_dsc (gpointer         data,
+		       GslWaveFileInfo *file_info,
+		       guint            nth_wave,
+		       GslErrorType    *error_p)
+{
+  GScanner *scanner;
+  WaveDsc *dsc;
+  guint token, i;
+  gint fd;
+
+  fd = open (file_info->file_name, O_RDONLY);
+  if (fd < 0)
+    {
+      *error_p = GSL_ERROR_OPEN_FAILED;
+      return NULL;
+    }
+
+  scanner = g_scanner_new (NULL);
+  scanner->config->symbol_2_token = TRUE;
+  scanner->input_name = file_info->file_name;
+  g_scanner_input_file (scanner, fd);
+  for (i = GSL_WAVE_TOKEN_WAVE; i < GSL_WAVE_TOKEN_LAST_FIELD; i++)
+    g_scanner_scope_add_symbol (scanner, 0, gsl_wave_token (i), GUINT_TO_POINTER (i));
+  for (i = GSL_WAVE_TOKEN_BIG_ENDIAN; i < GSL_WAVE_TOKEN_LAST_DATA; i++)
+    g_scanner_scope_add_symbol (scanner, 0, gsl_wave_token (i), GUINT_TO_POINTER (i));
+
+ continue_scanning:
+  dsc = gsl_new_struct0 (WaveDsc, 1);
+  dsc->wdsc.name = NULL;
+  dsc->wdsc.n_chunks = 0;
+  dsc->wdsc.chunks = NULL;
+  dsc->wdsc.n_channels = 1;
+  dsc->format = GSL_WAVE_FORMAT_SIGNED_16;
+  dsc->byte_order = G_LITTLE_ENDIAN;
+  dsc->dfl_mix_freq = 44100;
+  if (g_scanner_get_next_token (scanner) != GSL_WAVE_TOKEN_WAVE)
+    token = GSL_WAVE_TOKEN_WAVE;
+  else
+    token = gslwave_parse_wave_dsc (scanner, dsc, file_info->waves[nth_wave].name);
+  if (token != G_TOKEN_NONE || scanner->parse_errors)
+    {
+      gslwave_wave_dsc_free (dsc);
+      dsc = NULL;
+      if (!scanner->parse_errors)
+	g_scanner_unexp_token (scanner, token, "identifier", "keyword", NULL, "discarding wave", TRUE); /* FIXME */
+    }
+  else
+    {
+      if (dsc->wdsc.n_chunks && dsc->wdsc.name)
+	{
+	  /* found the correctly named wave and parsed it */
+	}
+      else
+	{
+	  /* got invalid/wrong wave */
+	  gslwave_wave_dsc_free (dsc);
+	  dsc = NULL;
+	  goto continue_scanning;	/* next attempt */
+	}
+    }
+  g_scanner_destroy (scanner);
+  close (fd);
+
+  return dsc ? &dsc->wdsc : NULL;
+}
+
+static void
+gslwave_free_wave_dsc (gpointer    data,
+		       GslWaveDsc *wave_dsc)
+{
+  WaveDsc *dsc = (WaveDsc*) wave_dsc;
+
+  gslwave_wave_dsc_free (dsc);
+}
+
+static GslDataHandle*
+gslwave_load_singlechunk_wave (GslWaveFileInfo *fi,
+			       const gchar     *wave_name,
+			       GslErrorType    *error_p)
+{
+  GslWaveDsc *wdsc;
+  guint i;
+
+  if (fi->n_waves == 1 && !wave_name)
+    i = 0;
+  else if (!wave_name)
+    {
+      /* don't know which wave to pick */
+      *error_p = GSL_ERROR_FORMAT_INVALID;
+      return NULL;
+    }
+  else /* find named wave */
+    for (i = 0; i < fi->n_waves; i++)
+      if (strcmp (fi->waves[i].name, wave_name) == 0)
+	break;
+  if (i >= fi->n_waves)
+    {
+      *error_p = GSL_ERROR_NOT_FOUND;
+      return NULL;
+    }
+
+  wdsc = gsl_wave_dsc_load (fi, i, error_p);
+  if (!wdsc)
+    return NULL;
+
+  if (wdsc->n_chunks == 1)
+    {
+      GslDataHandle *dhandle = gsl_wave_handle_create (wdsc, 0, error_p);
+
+      gsl_wave_dsc_free (wdsc);
+      return dhandle;
+    }
+
+  /* this is ridiculous, letting the chunk of a wave
+   * point to a wave with multiple chunks...
+   */
+  gsl_wave_dsc_free (wdsc);
+  *error_p = GSL_ERROR_FORMAT_INVALID;
+  return NULL;
+}
+
+static GslDataHandle*
+gslwave_create_chunk_handle (gpointer      data,
+			     GslWaveDsc   *wave_dsc,
+			     guint         nth_chunk,
+			     GslErrorType *error_p)
+{
+  WaveDsc *dsc = (WaveDsc*) wave_dsc;
+  FileInfo *fi = (FileInfo*) dsc->wdsc.file_info;
+  GslWaveChunkDsc *chunk = wave_dsc->chunks + nth_chunk;
+
+  if (chunk->loader_data1)	/* file_name */
+    {
+      GslDataHandle *dhandle;
+      GslWaveFileInfo *cfi;
+      gchar *string;
+
+
+      /* construct chunk file name from (hopefully) relative path
+       */
+      if (g_path_is_absolute (chunk->loader_data1))
+	string = g_strdup (chunk->loader_data1);
+      else
+	string = g_strdup_printf ("%s%c%s", fi->cwd, G_DIR_SEPARATOR, (char*) chunk->loader_data1);
+
+
+      /* first, try to load the chunk via registered loaders
+       */
+      cfi = gsl_wave_file_info_load (string, error_p);
+      if (cfi)
+	{
+	  /* FIXME: there's a potential attack here, in letting a single chunk
+	   * wave's chunk point to its own wave. this'll trigger recursions until
+	   * stack overflow
+	   */
+	  dhandle = gslwave_load_singlechunk_wave (cfi,
+						   chunk->loader_data2,	/* wave_name */
+						   error_p);
+	  gsl_wave_file_info_unref (cfi);
+	  g_free (string);
+	  return dhandle;
+	}
+
+
+      /* didn't work, assume it's a raw sample
+       */
+      if (chunk->loader_data2)	/* wave_name */
+	{
+	  /* raw samples don't give names to their data */
+	  *error_p = GSL_ERROR_NOT_FOUND;
+	  g_free (string);
+	  return NULL;
+	}
+      dhandle = gsl_wave_handle_new (string,	/* file_name */
+				     dsc->wdsc.n_channels,
+				     dsc->format,
+				     dsc->byte_order,
+				     chunk->loader_offset,	/* byte_offset */
+				     chunk->loader_length > 0	/* n_values */
+				     ? chunk->loader_length
+				     : -1);
+      *error_p = dhandle ? GSL_ERROR_NONE : GSL_ERROR_IO;
+      g_free (string);
+      return dhandle;
+    }	
+  else
+    {
+      /* no file_name specified */
+      *error_p = GSL_ERROR_NOT_FOUND;
+      return NULL;
+    }
+}
+
+void
+_gsl_init_loader_gslwave (void)
+{
+  static const gchar *file_exts[] = { "gslwave", NULL, };
+  static const gchar *mime_types[] = { "audio/x-gslwave", NULL, };
+  static const gchar *magics[] = { "0 string #GslWave", NULL, };
+  static GslLoader loader = {
+    "GslWave",
+    file_exts,
+    mime_types,
+    magics,
+    0,  /* priority */
+    NULL,
+    gslwave_load_file_info,
+    gslwave_free_file_info,
+    gslwave_load_wave_dsc,
+    gslwave_free_wave_dsc,
+    gslwave_create_chunk_handle,
+  };
+  static gboolean initialized = FALSE;
+
+  g_assert (initialized == FALSE);
+  initialized = TRUE;
+
+  gsl_loader_register (&loader);
+}
diff --git a/flow/gsl/gslloader-mad.c b/flow/gsl/gslloader-mad.c
new file mode 100644
index 0000000..984aa39
--- /dev/null
+++ b/flow/gsl/gslloader-mad.c
@@ -0,0 +1,210 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsl/gslloader.h"
+
+#include <gsl/gsldatahandle.h>
+#include "gsldatahandle-mad.h"
+
+#include <unistd.h>
+
+
+/* --- structures --- */
+typedef struct
+{
+  GslWaveFileInfo wfi;
+  guint           n_channels;
+  gfloat	  mix_freq;
+  gfloat	  osc_freq;
+} FileInfo;
+
+
+/* --- functions --- */
+static GslWaveFileInfo*
+mad_load_file_info (gpointer      data,
+		    const gchar  *file_name,
+		    GslErrorType *error_p)
+{
+  FileInfo *fi;
+  guint n_channels;
+  gfloat mix_freq;
+  GslErrorType error;
+
+  error = gsl_data_handle_mad_testopen (file_name, &n_channels, &mix_freq);
+  if (error)
+    {
+      *error_p = error;
+      return NULL;
+    }
+
+  fi = gsl_new_struct0 (FileInfo, 1);
+  fi->wfi.n_waves = 1;	/* we support only a single MPEG stream */
+  fi->wfi.waves = g_malloc0 (sizeof (fi->wfi.waves[0]) * fi->wfi.n_waves);
+  fi->wfi.waves[0].name = g_strdup (file_name);
+  fi->n_channels = n_channels;
+  fi->mix_freq = mix_freq;
+  fi->osc_freq = 440.0;	/* FIXME */
+
+  return &fi->wfi;
+}
+
+static void
+mad_free_file_info (gpointer         data,
+		    GslWaveFileInfo *file_info)
+{
+  FileInfo *fi = (FileInfo*) file_info;
+  guint i;
+
+  for (i = 0; i < fi->wfi.n_waves; i++)
+    g_free (fi->wfi.waves[i].name);
+  g_free (fi->wfi.waves);
+  gsl_delete_struct (FileInfo, fi);
+}
+
+static GslWaveDsc*
+mad_load_wave_dsc (gpointer         data,
+		   GslWaveFileInfo *file_info,
+		   guint            nth_wave,
+		   GslErrorType    *error_p)
+{
+  FileInfo *fi = (FileInfo*) file_info;
+  GslWaveDsc *wdsc = gsl_new_struct0 (GslWaveDsc, 1);
+
+  wdsc->name = g_strdup (fi->wfi.waves[0].name);
+  wdsc->n_channels = fi->n_channels;
+  wdsc->n_chunks = 1;
+  wdsc->chunks = g_new0 (GslWaveChunkDsc, 1);
+  wdsc->chunks[0].osc_freq = fi->osc_freq;
+  wdsc->chunks[0].mix_freq = fi->mix_freq;
+
+  return wdsc;
+}
+
+static void
+mad_free_wave_dsc (gpointer    data,
+		   GslWaveDsc *wdsc)
+{
+  g_free (wdsc->name);
+  g_free (wdsc->chunks);
+  gsl_delete_struct (GslWaveDsc, wdsc);
+}
+
+static GslDataHandle*
+mad_create_chunk_handle (gpointer      data,
+			 GslWaveDsc   *wdsc,
+			 guint         nth_chunk,
+			 GslErrorType *error_p)
+{
+  FileInfo *fi = (FileInfo*) wdsc->file_info;
+  GslDataHandle *dhandle;
+
+  g_return_val_if_fail (nth_chunk == 0, NULL);
+
+  dhandle = gsl_data_handle_new_mad (fi->wfi.file_name);
+
+  if (!dhandle)
+    *error_p = GSL_ERROR_OPEN_FAILED;
+  return dhandle;
+}
+
+
+#define	MAGIC_MPEG_HEADER	 "0 beshort   &0xffe0\n" /* MPEG */		\
+                                 "2 ubyte&0x0c <0x0c\n"	 /* valid samplefreq */	\
+                                 "2 ubyte&0xf0 <0xf0\n"	 /* valid bitrate */
+#define	MAGIC_MPEG10_I		(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x18\n"   /* 1.0 */		\
+                                 "1 byte&0x06 =0x06\n"   /* I */)
+#define	MAGIC_MPEG10_II		(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x18\n"   /* 1.0 */		\
+                                 "1 byte&0x06 =0x04\n"   /* II */)
+#define	MAGIC_MPEG10_III	(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x18\n"   /* 1.0 */		\
+                                 "1 byte&0x06 =0x02\n"   /* III */)
+#define	MAGIC_MPEG20_I		(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x10\n"   /* 2.0 */		\
+                                 "1 byte&0x06 =0x06\n"   /* I */)
+#define	MAGIC_MPEG20_II		(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x10\n"   /* 2.0 */		\
+                                 "1 byte&0x06 =0x04\n"   /* II */)
+#define	MAGIC_MPEG20_III	(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x10\n"   /* 2.0 */		\
+                                 "1 byte&0x06 =0x02\n"   /* III */)
+#define	MAGIC_MPEG25_I		(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x00\n"   /* 2.5 */		\
+                                 "1 byte&0x06 =0x06\n"   /* I */)
+#define	MAGIC_MPEG25_II		(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x00\n"   /* 2.5 */		\
+                                 "1 byte&0x06 =0x04\n"   /* II */)
+#define	MAGIC_MPEG25_III	(MAGIC_MPEG_HEADER				\
+                                 "1 byte&0x18 =0x00\n"   /* 2.5 */		\
+                                 "1 byte&0x06 =0x02\n"   /* III */)
+#define	MAGIC_RIFF_MPEG		("0  string  RIFF\n"				\
+                                 "8  string  WAVE\n"				\
+                                 "12 string  fmt\\s\n"	/* "fmt " */		\
+                                 "20 leshort 80\n"	/* format: MPEG */)
+#define	MAGIC_RIFF_MPEG_III	("0  string  RIFF\n"				\
+                                 "8  string  WAVE\n"				\
+                                 "12 string  fmt\\s\n"	/* "fmt " */		\
+                                 "20 leshort 85\n"	/* format: MPEG III */)
+#define	MAGIC_MPEG_ID3		("0  string  ID3\n"	/* ID3v2 tag for mp3 */	\
+                                 "3  ubyte   <0xff\n"	/* major version */	\
+                                 "4  ubyte   <0xff\n"	/* revision */)
+
+void
+_gsl_init_loader_mad (void)
+{
+  static const gchar *file_exts[] = {
+    "mp1", "mp2", "mp3",
+    NULL,
+  };
+  static const gchar *mime_types[] = {
+    "audio/mp3", "audio/x-mp3", "audio/mpg3", "audio/x-mpg3", "audio/mpeg3", "audio/x-mpeg3",
+    "audio/mp2", "audio/x-mp2", "audio/mpg2", "audio/x-mpg2", "audio/mpeg2", "audio/x-mpeg2",
+    "audio/mp1", "audio/x-mp1", "audio/mpg1", "audio/x-mpg1", "audio/mpeg1", "audio/x-mpeg1",
+    "audio/mpeg", "audio/x-mpeg",
+    NULL,
+  };
+  static const gchar *magics[] = {
+    MAGIC_MPEG10_I, MAGIC_MPEG10_II, MAGIC_MPEG10_III,
+    MAGIC_MPEG20_I, MAGIC_MPEG20_II, MAGIC_MPEG20_III,
+    MAGIC_MPEG25_I, MAGIC_MPEG25_II, MAGIC_MPEG25_III,
+    MAGIC_RIFF_MPEG, MAGIC_RIFF_MPEG_III,
+    MAGIC_MPEG_ID3,
+    NULL,
+  };
+  static GslLoader loader = {
+    "MPEG Audio (MAD: MPEG 1.0/2.0/2.5 Layer III/II/I Decoder)",
+    file_exts,
+    mime_types,
+    magics,
+    0,	/* priority */
+    NULL,
+    mad_load_file_info,
+    mad_free_file_info,
+    mad_load_wave_dsc,
+    mad_free_wave_dsc,
+    mad_create_chunk_handle,
+  };
+  static gboolean initialized = FALSE;
+
+  g_assert (initialized == FALSE);
+  initialized = TRUE;
+
+  if (GSL_HAVE_LIBMAD)
+    gsl_loader_register (&loader);
+}
diff --git a/flow/gsl/gslloader-oggvorbis.c b/flow/gsl/gslloader-oggvorbis.c
new file mode 100644
index 0000000..3ec3d88
--- /dev/null
+++ b/flow/gsl/gslloader-oggvorbis.c
@@ -0,0 +1,178 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 1998, 2000, 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsl/gslloader.h"
+
+#if GSL_HAVE_OGGVORBIS
+#include <gsl/gsldatahandle.h>
+#include "gsldatahandle-vorbis.h"
+
+#include <vorbis/vorbisfile.h>
+#include <string.h>
+#include <unistd.h>
+
+
+/* --- structures --- */
+typedef struct
+{
+  GslWaveFileInfo wfi;
+  OggVorbis_File  ofile;
+} FileInfo;
+
+
+/* --- functions --- */
+static GslWaveFileInfo*
+oggv_load_file_info (gpointer      data,
+		     const gchar  *file_name,
+		     GslErrorType *error_p)
+{
+  FileInfo *fi = gsl_new_struct0 (FileInfo, 1);
+  FILE *file;
+  gint err, i;
+
+  file = fopen (file_name, "r");
+  if (!file)
+    {
+      *error_p = GSL_ERROR_OPEN_FAILED;
+      return NULL;
+    }
+
+  fi = gsl_new_struct0 (FileInfo, 1);
+  err = ov_open (file, &fi->ofile, NULL, 0);
+  if (err)
+    {
+      fclose (file);
+      gsl_delete_struct (FileInfo, fi);
+      *error_p = GSL_ERROR_CODEC_FAILURE;
+      return NULL;
+    }
+
+  fi->wfi.n_waves = ov_streams (&fi->ofile);
+  fi->wfi.waves = g_malloc0 (sizeof (fi->wfi.waves[0]) * fi->wfi.n_waves);
+  for (i = 0; i < fi->wfi.n_waves; i++)
+    {
+      vorbis_comment *vc = ov_comment (&fi->ofile, i);
+      guint n;
+
+      for (n = 0; n < vc->comments; n++)
+	if (strcmp (vc->user_comments[n], "title=") == 0)
+	  break;
+      if (n < vc->comments)
+	fi->wfi.waves[i].name = g_strdup (vc->user_comments[n] + 6);
+      else
+	fi->wfi.waves[i].name = g_strdup_printf ("Unnamed-%u", i);
+    }
+
+  return &fi->wfi;
+}
+
+static void
+oggv_free_file_info (gpointer         data,
+		     GslWaveFileInfo *file_info)
+{
+  FileInfo *fi = (FileInfo*) file_info;
+  guint i;
+
+  for (i = 0; i < fi->wfi.n_waves; i++)
+    g_free (fi->wfi.waves[i].name);
+  g_free (fi->wfi.waves);
+  ov_clear (&fi->ofile);
+  gsl_delete_struct (FileInfo, fi);
+}
+
+static GslWaveDsc*
+oggv_load_wave_dsc (gpointer         data,
+		    GslWaveFileInfo *file_info,
+		    guint            nth_wave,
+		    GslErrorType    *error_p)
+{
+  FileInfo *fi = (FileInfo*) file_info;
+  GslWaveDsc *wdsc = gsl_new_struct0 (GslWaveDsc, 1);
+  vorbis_info *vi = ov_info (&fi->ofile, nth_wave);
+
+  wdsc->name = g_strdup (fi->wfi.waves[nth_wave].name);
+  wdsc->n_channels = vi->channels;
+  wdsc->n_chunks = 1;
+  wdsc->chunks = g_new0 (GslWaveChunkDsc, 1);
+  wdsc->chunks[0].osc_freq = 440.0; /* FIXME */
+  wdsc->chunks[0].mix_freq = vi->rate;
+  wdsc->chunks[0].loader_offset = nth_wave;	/* lbitstream */
+
+  return wdsc;
+}
+
+static void
+oggv_free_wave_dsc (gpointer    data,
+		    GslWaveDsc *wdsc)
+{
+  g_free (wdsc->name);
+  g_free (wdsc->chunks);
+  gsl_delete_struct (GslWaveDsc, wdsc);
+}
+
+static GslDataHandle*
+oggv_create_chunk_handle (gpointer      data,
+			  GslWaveDsc   *wdsc,
+			  guint         nth_chunk,
+			  GslErrorType *error_p)
+{
+  FileInfo *fi = (FileInfo*) wdsc->file_info;
+  GslDataHandle *dhandle;
+
+  g_return_val_if_fail (nth_chunk == 0, NULL);
+
+  dhandle = gsl_data_handle_new_ogg_vorbis (fi->wfi.file_name,
+					    wdsc->chunks[0].loader_offset); /* lbitstream */
+  if (!dhandle)
+    *error_p = GSL_ERROR_OPEN_FAILED;
+  return dhandle;
+}
+
+void
+_gsl_init_loader_oggvorbis (void)
+{
+  static const gchar *file_exts[] = { "ogg", NULL, };
+  static const gchar *mime_types[] = { "application/x-ogg", "audio/x-vorbis", "audio/x-ogg", NULL, };
+  static const gchar *magics[] = { "0 string OggS\n" "29 string vorbis", NULL, };
+  static GslLoader loader = {
+    "Ogg/Vorbis",
+    file_exts,
+    mime_types,
+    magics,
+    0,  /* priority */
+    NULL,
+    oggv_load_file_info,
+    oggv_free_file_info,
+    oggv_load_wave_dsc,
+    oggv_free_wave_dsc,
+    oggv_create_chunk_handle,
+  };
+  static gboolean initialized = FALSE;
+
+  g_assert (initialized == FALSE);
+  initialized = TRUE;
+
+  gsl_loader_register (&loader);
+}
+#else
+void
+_gsl_init_loader_oggvorbis (void)
+{
+  /* dummy */
+}
+#endif /* GSL_HAVE_OGGVORBIS */
diff --git a/flow/gsl/gslloader-wav.c b/flow/gsl/gslloader-wav.c
new file mode 100644
index 0000000..d0a1c1e
--- /dev/null
+++ b/flow/gsl/gslloader-wav.c
@@ -0,0 +1,442 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 1998, 2000, 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslloader.h"
+
+#include "gsldatahandle.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+
+
+/* load routine for the RIFF/WAVE sample format
+ * ref.: C't 01/1993 pp. 213
+ */
+
+typedef guint32 DWord;
+typedef guint16 Word;
+#define	DWORD_FROM_BE	GUINT32_FROM_BE
+#define	DWORD_FROM_LE	GUINT32_FROM_LE
+#define	WORD_FROM_LE	GUINT16_FROM_LE
+
+
+/* --- debugging and errors --- */
+#define WAV_DEBUG		GSL_DEBUG_FUNCTION (GSL_MSG_DATA_HANDLE, "WAV")
+#define WAV_MSG			GSL_MESSAGE_FUNCTION (GSL_MSG_DATA_HANDLE, "WAV")
+
+
+/* --- functions --- */
+typedef struct
+{
+  DWord main_chunk;     /* 'RIFF', big endian as int */
+  DWord file_length;	/* file length */
+  DWord chunk_type;     /* 'WAVE', big endian as int */
+} WavHeader;
+static GslErrorType
+wav_read_header (gint       fd,
+		 WavHeader *header)
+{
+  guint n_bytes;
+
+  memset (header, 0, sizeof (*header));
+
+  /* read header contents */
+  n_bytes = 4 + 4 + 4;
+  g_assert (n_bytes == sizeof (*header));
+  if (read (fd, header, n_bytes) != n_bytes)
+    {
+      WAV_DEBUG ("failed to read WavHeader");
+      return GSL_ERROR_IO;
+    }
+
+  /* endianess corrections */
+  header->main_chunk = DWORD_FROM_BE (header->main_chunk);
+  header->file_length = DWORD_FROM_LE (header->file_length);
+  header->chunk_type = DWORD_FROM_BE (header->chunk_type);
+
+  /* validation */
+  if (header->main_chunk != ('R' << 24 | 'I' << 16 | 'F' << 8 | 'F'))
+    {
+      WAV_DEBUG ("unmatched token 'RIFF'");
+      return GSL_ERROR_FORMAT_INVALID;
+    }
+  if (header->file_length < 40)
+    {
+      WAV_DEBUG ("file length (%u) too small", header->file_length);
+      return GSL_ERROR_FORMAT_INVALID;
+    }
+  if (header->chunk_type != ('W' << 24 | 'A' << 16 | 'V' << 8 | 'E'))
+    {
+      WAV_DEBUG ("unmatched token 'WAVE'");
+      return GSL_ERROR_FORMAT_INVALID;
+    }
+
+  return GSL_ERROR_NONE;
+}
+
+typedef struct
+{
+  DWord sub_chunk;              /* 'fmt ', big endian as int */
+  DWord length;                 /* sub chunk length, must be 16 */
+  Word  format;                 /* 1 for PCM */
+  Word  n_channels;             /* 1 = Mono, 2 = Stereo */
+  DWord sample_freq;
+  DWord byte_per_second;
+  Word  byte_per_sample;        /* 1 = 8bit, 2 = 16bit */
+  Word  bit_per_sample;         /* 8, 12 or 16 */
+} FmtHeader;
+static GslErrorType
+wav_read_fmt_header (gint       fd,
+		     FmtHeader *header)
+{
+  guint n_bytes;
+
+  memset (header, 0, sizeof (*header));
+
+  /* read header contents */
+  n_bytes = 4 + 4 + 2 + 2 + 4 + 4 + 2 + 2;
+  g_assert (n_bytes == sizeof (*header));
+  if (read (fd, header, n_bytes) != n_bytes)
+    {
+      WAV_DEBUG ("failed to read FmtHeader");
+      return GSL_ERROR_IO;
+    }
+
+  /* endianess corrections */
+  header->sub_chunk = DWORD_FROM_BE (header->sub_chunk);
+  header->length = DWORD_FROM_LE (header->length);
+  header->format = WORD_FROM_LE (header->format);
+  header->n_channels = WORD_FROM_LE (header->n_channels);
+  header->sample_freq = DWORD_FROM_LE (header->sample_freq);
+  header->byte_per_second = DWORD_FROM_LE (header->byte_per_second);
+  header->byte_per_sample = WORD_FROM_LE (header->byte_per_sample);
+  header->bit_per_sample = WORD_FROM_LE (header->bit_per_sample);
+
+  /* validation */
+  if (header->sub_chunk != ('f' << 24 | 'm' << 16 | 't' << 8 | ' '))
+    {
+      WAV_DEBUG ("unmatched token 'fmt '");
+      return GSL_ERROR_FORMAT_UNKNOWN;
+    }
+  if (header->format != 1 /* PCM */ ||
+      header->n_channels > 2 || header->n_channels < 1)
+    {
+      WAV_DEBUG ("invalid format (%u) or n_channels (%u)", header->format, header->n_channels);
+      return GSL_ERROR_FORMAT_UNKNOWN;
+    }
+  if (header->length < 16)
+    {
+      WAV_DEBUG ("WAVE header too short (%u)", header->length);
+      return GSL_ERROR_FORMAT_INVALID;
+    }
+  if (header->sample_freq < 1378 || header->sample_freq > 96000)
+    {
+      WAV_DEBUG ("invalid sample_freq (%u)", header->sample_freq);
+      return GSL_ERROR_FORMAT_UNKNOWN;
+    }
+  if (header->byte_per_sample < 1 || header->byte_per_sample > 4 ||
+      (header->bit_per_sample != 8 && header->bit_per_sample != 12 && header->bit_per_sample != 16))
+    {
+      WAV_DEBUG ("invalid byte_per_sample (%u) or bit_per_sample (%u)", header->byte_per_sample, header->bit_per_sample);
+      return GSL_ERROR_FORMAT_UNKNOWN;
+    }
+  if (header->byte_per_second != header->sample_freq * header->byte_per_sample ||
+      header->byte_per_sample != (header->bit_per_sample + 7) / 8 * header->n_channels)
+    {
+      WAV_DEBUG ("invalid byte_per_second (%u!=%u) or byte_per_sample (%u!=%u)",
+		 header->byte_per_second, header->sample_freq * header->byte_per_sample,
+		 header->byte_per_sample, (header->bit_per_sample + 7) / 8 * header->n_channels);
+      return GSL_ERROR_FORMAT_INVALID;
+    }
+  if (header->length > 16)
+    {
+      guint n;
+
+      WAV_DEBUG ("WAVE header too long (%u)", header->length);
+
+      n = header->length - 16;
+      while (n)
+	{
+	  guint8 junk[64];
+	  guint l = MIN (n, 64);
+
+	  l = read (fd, junk, l);
+	  if (l < 1 || l > n)
+	    {
+	      WAV_DEBUG ("failed to read FmtHeader");
+	      return GSL_ERROR_IO;
+	    }
+	  n -= l;
+	}
+
+      WAV_MSG (GSL_ERROR_CONTENT_GLITCH, "skipping %u bytes of junk in WAVE header", header->length - 16);
+    }
+
+  return GSL_ERROR_NONE;
+}
+
+typedef struct
+{
+  DWord data_chunk;             /* 'data', big endian as int */
+  DWord data_length;
+} DataHeader;
+static GslErrorType
+wav_read_data_header (gint        fd,
+		      DataHeader *header,
+		      guint       byte_alignment)
+{
+  guint n_bytes;
+
+  memset (header, 0, sizeof (*header));
+
+  /* read header contents */
+  n_bytes = 4 + 4;
+  g_assert (n_bytes == sizeof (*header));
+  if (read (fd, header, n_bytes) != n_bytes)
+    {
+      WAV_DEBUG ("failed to read DataHeader");
+      return GSL_ERROR_IO;
+    }
+
+  /* endianess corrections */
+  header->data_chunk = DWORD_FROM_BE (header->data_chunk);
+  header->data_length = DWORD_FROM_LE (header->data_length);
+
+  /* validation */
+  if (header->data_chunk != ('d' << 24 | 'a' << 16 | 't' << 8 | 'a'))
+    {
+      guchar chunk[5];
+      gchar *esc;
+
+      chunk[0] = header->data_chunk >> 24;
+      chunk[1] = (header->data_chunk >> 16) & 0xff;
+      chunk[2] = (header->data_chunk >> 8) & 0xff;
+      chunk[3] = header->data_chunk & 0xff;
+      chunk[4] = 0;
+      esc = g_strescape (chunk, NULL);
+
+      /* skip chunk and retry */
+      WAV_DEBUG ("ignoring sub-chunk '%s'", esc);
+      g_free (esc);
+      if (lseek (fd, header->data_length, SEEK_CUR) < 0)
+	{
+	  WAV_DEBUG ("failed to seek while skipping sub-chunk");
+	  return GSL_ERROR_IO;
+	}
+      return wav_read_data_header (fd, header, byte_alignment);
+    }
+  if (header->data_length < 1 || header->data_length % byte_alignment != 0)
+    {
+      WAV_DEBUG ("invalid data length (%u) or alignment (%u)",
+		 header->data_length, header->data_length % byte_alignment);
+      return GSL_ERROR_FORMAT_INVALID;
+    }
+
+  return GSL_ERROR_NONE;
+}
+
+typedef struct
+{
+  GslWaveFileInfo wfi;
+  gint            fd;
+} FileInfo;
+
+static GslWaveFileInfo*
+wav_load_file_info (gpointer      data,
+		    const gchar  *file_name,
+		    GslErrorType *error_p)
+{
+  WavHeader wav_header;
+  FileInfo *fi;
+  gint fd;
+
+  fd = open (file_name, O_RDONLY);
+  if (fd < 0)
+    {
+      *error_p = GSL_ERROR_OPEN_FAILED;
+      return NULL;
+    }
+
+  *error_p = wav_read_header (fd, &wav_header);
+  if (*error_p)
+    {
+      close (fd);
+      return NULL;
+    }
+
+  fi = gsl_new_struct0 (FileInfo, 1);
+  fi->wfi.n_waves = 1;
+  fi->wfi.waves = g_malloc0 (sizeof (fi->wfi.waves[0]) * fi->wfi.n_waves);
+  fi->wfi.waves[0].name = g_strdup (file_name);
+  fi->fd = fd;
+
+  return &fi->wfi;
+}
+
+static void
+wav_free_file_info (gpointer         data,
+		    GslWaveFileInfo *file_info)
+{
+  FileInfo *fi = (FileInfo*) file_info;
+
+  g_free (fi->wfi.waves[0].name);
+  g_free (fi->wfi.waves);
+  close (fi->fd);
+  gsl_delete_struct (FileInfo, fi);
+}
+
+typedef struct
+{
+  GslWaveDsc wdsc;
+  GslLong    data_offset;
+  GslLong    n_values;
+  GslWaveFormatType format;
+} WaveDsc;
+
+static GslWaveDsc*
+wav_load_wave_dsc (gpointer         data,
+		   GslWaveFileInfo *file_info,
+		   guint            nth_wave,
+		   GslErrorType    *error_p)
+{
+  FileInfo *fi = (FileInfo*) file_info;
+  DataHeader data_header;
+  FmtHeader fmt_header;
+  WaveDsc *dsc;
+  GslWaveFormatType format;
+  GslLong data_offset, data_width;
+
+  g_return_val_if_fail (nth_wave == 0, NULL);
+
+  if (lseek (fi->fd, sizeof (WavHeader), SEEK_SET) != sizeof (WavHeader))
+    {
+      WAV_DEBUG ("failed to seek to end of WavHeader");
+      *error_p = GSL_ERROR_IO;
+      return NULL;
+    }
+
+  *error_p = wav_read_fmt_header (fi->fd, &fmt_header);
+  if (*error_p)
+    return NULL;
+
+  data_width = (fmt_header.bit_per_sample + 7) / 8;
+  *error_p = wav_read_data_header (fi->fd, &data_header, data_width * fmt_header.n_channels);
+  data_offset = lseek (fi->fd, 0, SEEK_CUR);
+  if (data_offset < sizeof (WavHeader) && !*error_p)
+    {
+      WAV_DEBUG ("failed to seek to start of data");
+      *error_p = GSL_ERROR_IO;
+    }
+  if (*error_p)
+    return NULL;
+
+  switch (fmt_header.bit_per_sample)
+    {
+    case 8:	format = GSL_WAVE_FORMAT_UNSIGNED_8;	break;
+    case 12:	format = GSL_WAVE_FORMAT_SIGNED_12;	break;
+    case 16:	format = GSL_WAVE_FORMAT_SIGNED_16;	break;
+    default:
+      WAV_DEBUG ("unrecognized sample width (%u)", fmt_header.bit_per_sample);
+      *error_p = GSL_ERROR_FORMAT_UNKNOWN;
+      return NULL;
+    }
+  if (0)
+    WAV_DEBUG ("n_channels: %d sample_freq: %d bit_width: %u",
+	       fmt_header.n_channels, fmt_header.sample_freq, fmt_header.bit_per_sample);
+
+  dsc = gsl_new_struct0 (WaveDsc, 1);
+  dsc->wdsc.name = g_strdup (fi->wfi.waves[0].name);
+  dsc->wdsc.n_channels = fmt_header.n_channels;
+  dsc->wdsc.n_chunks = 1;
+  dsc->wdsc.chunks = g_malloc0 (sizeof (dsc->wdsc.chunks[0]) * dsc->wdsc.n_chunks);
+  dsc->wdsc.chunks[0].mix_freq = fmt_header.sample_freq;
+  dsc->wdsc.chunks[0].osc_freq = 440.0;	/* FIXME */
+  dsc->data_offset = data_offset;
+  dsc->n_values = data_header.data_length / data_width;
+  dsc->format = format;
+
+  return &dsc->wdsc;
+}
+
+static void
+wav_free_wave_dsc (gpointer    data,
+		   GslWaveDsc *wave_dsc)
+{
+  WaveDsc *dsc = (WaveDsc*) wave_dsc;
+
+  g_free (dsc->wdsc.name);
+  g_free (dsc->wdsc.chunks);
+  gsl_delete_struct (WaveDsc, dsc);
+}
+
+static GslDataHandle*
+wav_create_chunk_handle (gpointer      data,
+			 GslWaveDsc   *wave_dsc,
+			 guint         nth_chunk,
+			 GslErrorType *error_p)
+{
+  WaveDsc *dsc = (WaveDsc*) wave_dsc;
+  GslDataHandle *dhandle;
+
+  g_return_val_if_fail (nth_chunk == 0, NULL);
+
+  dhandle = gsl_wave_handle_new (dsc->wdsc.file_info->file_name,
+				 dsc->wdsc.n_channels,
+				 dsc->format, G_LITTLE_ENDIAN,
+				 dsc->data_offset, dsc->n_values);
+  return dhandle;
+}
+
+void
+_gsl_init_loader_wav (void)
+{
+  static const gchar *file_exts[] = { "wav", NULL, };
+  static const gchar *mime_types[] = { "audio/wav", "audio/x-wav", NULL, };
+  static const gchar *magics[] = {
+    (
+     "0  string  RIFF\n"
+     "8  string  WAVE\n"
+     "12 string  fmt\\s\n"	/* expect "fmt " */
+     "16 lelong  >15\n"		/* expect valid sub chunk length */
+     "20 leshort =1\n"		/* expect PCM format */
+     ),
+    NULL,
+  };
+  static GslLoader loader = {
+    "RIFF, WAVE audio, PCM",
+    file_exts,
+    mime_types,
+    magics,
+    0,  /* priority */
+    NULL,
+    wav_load_file_info,
+    wav_free_file_info,
+    wav_load_wave_dsc,
+    wav_free_wave_dsc,
+    wav_create_chunk_handle,
+  };
+  static gboolean initialized = FALSE;
+
+  g_assert (initialized == FALSE);
+  initialized = TRUE;
+
+  gsl_loader_register (&loader);
+}
diff --git a/flow/gsl/gslloader.c b/flow/gsl/gslloader.c
new file mode 100644
index 0000000..002e39f
--- /dev/null
+++ b/flow/gsl/gslloader.c
@@ -0,0 +1,335 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include        "gslloader.h"
+
+#include        "gslcommon.h"
+#include        "gsldatahandle.h"
+#include        "gslmagic.h"
+#include        <string.h>
+
+
+/* --- variables --- */
+static GslLoader *gsl_loader_list = NULL;
+static GslRing   *gsl_magic_list = NULL;
+
+
+/* --- functions --- */
+static GslLoader*
+loader_find_by_name (const gchar *name)
+{
+  GslLoader *loader;
+
+  for (loader = gsl_loader_list; loader != NULL; loader = loader->next)
+    if (strcmp (name, loader->name) == 0)
+      return loader;
+  return NULL;
+}
+
+void
+gsl_loader_register (GslLoader *loader)
+{
+  g_return_if_fail (loader != NULL);
+  g_return_if_fail (loader->name != NULL);
+  g_return_if_fail (loader->extensions || loader->mime_types || loader->magic_specs);
+  g_return_if_fail (loader_find_by_name (loader->name) == NULL);
+  g_return_if_fail (loader->next == NULL);
+  g_return_if_fail (loader->load_file_info != NULL);
+  g_return_if_fail (loader->free_file_info != NULL);
+  g_return_if_fail (loader->load_wave_dsc != NULL);
+  g_return_if_fail (loader->free_wave_dsc != NULL);
+  g_return_if_fail (loader->create_chunk_handle != NULL);
+
+  loader->next = gsl_loader_list;
+  gsl_loader_list = loader;
+
+  if (loader->magic_specs)
+    {
+      GslMagic *magic;
+      guint i, j;
+
+      for (i = 0; loader->magic_specs[i]; i++)
+	{
+	  if (loader->extensions)
+	    for (j = 0; loader->extensions[j]; j++)
+	      {
+		magic = gsl_magic_create (loader, loader->priority,
+					  loader->extensions[j], loader->magic_specs[i]);
+		gsl_magic_list = gsl_ring_append (gsl_magic_list, magic);
+	      }
+	  else
+	    {
+	      magic = gsl_magic_create (loader, loader->priority,
+					NULL, loader->magic_specs[i]);
+	      gsl_magic_list = gsl_ring_append (gsl_magic_list, magic);
+	    }
+	}
+    }
+}
+
+GslLoader*
+gsl_loader_match (const gchar *file_name)
+{
+  GslMagic *magic;
+
+  g_return_val_if_fail (file_name != NULL, NULL);
+
+  magic = gsl_magic_list_match_file (gsl_magic_list, file_name);
+  if (magic)
+    return magic->data;
+
+  return NULL;
+}
+
+GslWaveFileInfo*
+gsl_wave_file_info_load (const gchar  *file_name,
+			 GslErrorType *error_p)
+{
+  GslWaveFileInfo *finfo = NULL;
+  GslErrorType error = GSL_ERROR_NONE;
+  GslLoader *loader;
+
+  if (error_p)
+    *error_p = GSL_ERROR_INTERNAL;
+  g_return_val_if_fail (file_name != NULL, NULL);
+
+  loader = gsl_loader_match (file_name);
+  if (loader)
+    {
+      finfo = loader->load_file_info (loader->data, file_name, &error);
+      if (error && finfo)
+	{
+	  /* loaders shouldn't do this */
+	  loader->free_file_info (loader->data, finfo);
+	  finfo = NULL;
+	}
+      if (!finfo && !error)
+	error = GSL_ERROR_FILE_EMPTY;	/* FIXME: try next loader */
+      if (finfo)
+	{
+	  if (finfo->n_waves > 0)
+	    {
+	      guint i;
+
+	      g_return_val_if_fail (finfo->loader == NULL, NULL);
+	      g_return_val_if_fail (finfo->file_name == NULL, NULL);
+
+	      for (i = 0; i < finfo->n_waves; i++)
+		g_return_val_if_fail (finfo->waves[i].name != NULL, NULL);
+
+	      finfo->file_name = g_strdup (file_name);
+	      finfo->loader = loader;
+	      finfo->ref_count = 1;
+	    }
+	  else
+	    {
+	      loader->free_file_info (loader->data, finfo);
+	      finfo = NULL;
+	      error = GSL_ERROR_FILE_EMPTY;   /* FIXME: try next loader */
+	    }
+	}
+    }
+  else /* no loader match */
+    {
+      /* try to provide appropriate error code */
+      error = gsl_check_file (file_name, "rf");
+      if (!error)
+	error = GSL_ERROR_FORMAT_UNKNOWN;
+    }
+
+  if (error_p)
+    *error_p = error;
+
+  return finfo;
+}
+
+void
+gsl_wave_file_info_unref (GslWaveFileInfo *wave_file_info)
+{
+  g_return_if_fail (wave_file_info != NULL);
+  g_return_if_fail (wave_file_info->ref_count > 0);
+
+  wave_file_info->ref_count--;
+  if (!wave_file_info->ref_count)
+    {
+      GslLoader *loader = wave_file_info->loader;
+
+      g_free (wave_file_info->file_name);
+      wave_file_info->file_name = NULL;
+      wave_file_info->loader = NULL;
+
+      loader->free_file_info (loader->data, wave_file_info);
+    }
+}
+
+GslWaveFileInfo*
+gsl_wave_file_info_ref (GslWaveFileInfo *wave_file_info)
+{
+  g_return_val_if_fail (wave_file_info != NULL, NULL);
+  g_return_val_if_fail (wave_file_info->ref_count > 0, NULL);
+
+  wave_file_info->ref_count++;
+
+  return wave_file_info;
+}
+
+GslWaveDsc*
+gsl_wave_dsc_load (GslWaveFileInfo *wave_file_info,
+		   guint            nth_wave,
+		   GslErrorType    *error_p)
+{
+  GslErrorType error = GSL_ERROR_NONE;
+  GslWaveDsc *wdsc;
+  GslLoader *loader;
+
+  if (error_p)
+    *error_p = GSL_ERROR_INTERNAL;
+  g_return_val_if_fail (wave_file_info != NULL, NULL);
+  g_return_val_if_fail (wave_file_info->loader != NULL, NULL);
+  g_return_val_if_fail (nth_wave < wave_file_info->n_waves, NULL);
+
+  loader = wave_file_info->loader;
+  wdsc = loader->load_wave_dsc (loader->data, wave_file_info, nth_wave,&error);
+
+  if (error && wdsc)
+    {
+      /* loaders shouldn't do this */
+      loader->free_wave_dsc (loader->data, wdsc);
+      wdsc = NULL;
+    }
+  if (!wdsc && !error)
+    error = GSL_ERROR_FILE_EMPTY;
+  if (wdsc)
+    {
+      if (wdsc->n_chunks > 0)
+	{
+	  g_return_val_if_fail (wdsc->file_info == NULL, NULL);
+	  g_return_val_if_fail (wdsc->name && strcmp (wdsc->name, wave_file_info->waves[nth_wave].name) == 0, NULL);
+
+	  wdsc->file_info = wave_file_info;
+	  gsl_wave_file_info_ref (wave_file_info);
+	}
+      else
+	{
+	  loader->free_wave_dsc (loader->data, wdsc);
+	  wdsc = NULL;
+	  error = GSL_ERROR_FILE_EMPTY;
+	}
+    }
+
+  if (error_p)
+    *error_p = error;
+
+  return wdsc;
+}
+
+void
+gsl_wave_dsc_free (GslWaveDsc *wave_dsc)
+{
+  GslWaveFileInfo *file_info;
+
+  g_return_if_fail (wave_dsc != NULL);
+  g_return_if_fail (wave_dsc->file_info != NULL);
+
+  file_info = wave_dsc->file_info;
+  wave_dsc->file_info = NULL;
+
+  file_info->loader->free_wave_dsc (file_info->loader->data, wave_dsc);
+
+  gsl_wave_file_info_unref (file_info);
+}
+
+GslDataHandle*
+gsl_wave_handle_create (GslWaveDsc   *wave_dsc,
+			guint	      nth_chunk,
+			GslErrorType *error_p)
+{
+  GslErrorType error = GSL_ERROR_NONE;
+  GslDataHandle *dhandle;
+  GslLoader *loader;
+
+  if (error_p)
+    *error_p = GSL_ERROR_INTERNAL;
+  g_return_val_if_fail (wave_dsc != NULL, NULL);
+  g_return_val_if_fail (wave_dsc->file_info != NULL, NULL);
+  g_return_val_if_fail (nth_chunk < wave_dsc->n_chunks, NULL);
+
+  loader = wave_dsc->file_info->loader;
+
+  dhandle = loader->create_chunk_handle (loader->data,
+					 wave_dsc,
+					 nth_chunk,
+					 &error);
+  if (error && dhandle)
+    {
+      /* loaders shouldn't do this */
+      gsl_data_handle_unref (dhandle);
+      dhandle = NULL;
+    }
+  if (!dhandle && !error)
+    error = GSL_ERROR_FORMAT_INVALID;
+
+  if (error_p)
+    *error_p = error;
+
+  return dhandle;
+}
+
+GslWaveChunk*
+gsl_wave_chunk_create (GslWaveDsc   *wave_dsc,
+		       guint         nth_chunk,
+		       GslErrorType *error_p)
+{
+  GslDataHandle *dhandle;
+  GslDataCache *dcache;
+  GslWaveChunk *wchunk;
+
+  if (error_p)
+    *error_p = GSL_ERROR_INTERNAL;
+  g_return_val_if_fail (wave_dsc != NULL, NULL);
+  g_return_val_if_fail (nth_chunk < wave_dsc->n_chunks, NULL);
+
+  dhandle = gsl_wave_handle_create (wave_dsc, nth_chunk, error_p);
+  if (!dhandle)
+    return NULL;
+
+  if (error_p)
+    *error_p = GSL_ERROR_IO;
+
+  /* FIXME: we essentially create a dcache for each wchunk here ;( */
+
+  dcache = gsl_data_cache_from_dhandle (dhandle, gsl_get_config ()->wave_chunk_padding * wave_dsc->n_channels);
+  gsl_data_handle_unref (dhandle);
+  if (!dcache)
+    return NULL;
+  /* dcache keeps dhandle alive */
+
+  wchunk = gsl_wave_chunk_new (dcache,
+			       wave_dsc->chunks[nth_chunk].osc_freq,
+			       wave_dsc->chunks[nth_chunk].mix_freq,
+			       wave_dsc->chunks[nth_chunk].loop_type,
+			       wave_dsc->chunks[nth_chunk].loop_start,
+			       wave_dsc->chunks[nth_chunk].loop_end,
+			       wave_dsc->chunks[nth_chunk].loop_count);
+  gsl_data_cache_unref (dcache);
+
+  if (error_p && wchunk)
+    *error_p = GSL_ERROR_NONE;
+
+  return wchunk;
+}
diff --git a/flow/gsl/gslloader.h b/flow/gsl/gslloader.h
new file mode 100644
index 0000000..e4b391c
--- /dev/null
+++ b/flow/gsl/gslloader.h
@@ -0,0 +1,136 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_LOADER_H__
+#define __GSL_LOADER_H__
+
+#include <gsl/gsldefs.h>
+#include <gsl/gslcommon.h>
+#include <gsl/gslwavechunk.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+typedef struct _GslWaveFileInfo GslWaveFileInfo;
+typedef struct _GslWaveDsc      GslWaveDsc;
+typedef struct _GslWaveChunkDsc GslWaveChunkDsc;
+
+/* --- structures --- */
+struct _GslWaveFileInfo
+{
+  guint	   n_waves;
+  struct {
+    gchar *name;
+  }       *waves;
+
+  /*< private >*/
+  gchar     *file_name;
+  GslLoader *loader;
+  guint      ref_count;
+};
+struct _GslWaveDsc
+{
+  gchar		  *name;
+  guint	           n_chunks;
+  GslWaveChunkDsc *chunks;
+  guint            n_channels;
+  /*< private >*/
+  GslWaveFileInfo *file_info;
+};
+struct _GslWaveChunkDsc
+{
+  gfloat	  osc_freq;
+  gfloat	  mix_freq;
+  GslWaveLoopType loop_type;
+  GslLong	  loop_start;	/* sample offset */
+  GslLong	  loop_end;	/* sample offset */
+  guint		  loop_count;
+  /* loader-specific */
+  GslLong         loader_offset;
+  GslLong         loader_length;
+  gpointer	  loader_data1; /* generic pointers for more data */
+  gpointer	  loader_data2;
+};
+
+
+/* --- functions --- */
+GslWaveFileInfo*       gsl_wave_file_info_load	(const gchar	 *file_name,
+						 GslErrorType	 *error);
+GslWaveFileInfo*       gsl_wave_file_info_ref   (GslWaveFileInfo *wave_file_info);
+void                   gsl_wave_file_info_unref (GslWaveFileInfo *wave_file_info);
+GslWaveDsc*	       gsl_wave_dsc_load	(GslWaveFileInfo *wave_file_info,
+						 guint		  nth_wave,
+						 GslErrorType	 *error);
+void		       gsl_wave_dsc_free	(GslWaveDsc	 *wave_dsc);
+GslDataHandle*	       gsl_wave_handle_create	(GslWaveDsc	 *wave_dsc,
+						 guint		  nth_chunk,
+						 GslErrorType	 *error);
+GslWaveChunk*	       gsl_wave_chunk_create	(GslWaveDsc	 *wave_dsc,
+						 guint		  nth_chunk,
+						 GslErrorType	 *error);
+
+
+/* --- loader impl --- */
+struct _GslLoader
+{
+  const gchar *name;		/* format/loader name, e.g. "GslWave" or "WAVE audio, RIFF (little-endian)" */
+
+  /* at least one of the
+   * following three must
+   * be non-NULL
+   */
+  const gchar **extensions;	/* e.g.: "mp3", "ogg" or "gslwave" */
+  const gchar **mime_types;	/* e.g.: "audio/x-mpg3" or "audio/x-wav" */
+  const gchar **magic_specs;	/* e.g.: "0 string RIFF\n8 string WAVE\n" or "0 string #GslWave\n" */
+
+  gint   priority;   /* -100=high, +100=low, 0=default */
+
+  /*< private >*/
+  gpointer		  data;
+  GslWaveFileInfo*	(*load_file_info)	(gpointer	   data,
+						 const gchar	  *file_name,
+						 GslErrorType	  *error);
+  void			(*free_file_info)	(gpointer	   data,
+						 GslWaveFileInfo  *file_info);
+  GslWaveDsc*		(*load_wave_dsc)	(gpointer	   data,
+						 GslWaveFileInfo  *file_info,
+						 guint		   nth_wave,
+						 GslErrorType	  *error);
+  void			(*free_wave_dsc)	(gpointer	   data,
+						 GslWaveDsc	  *wave_dsc);
+  GslDataHandle*	(*create_chunk_handle)	(gpointer	   data,
+						 GslWaveDsc	  *wave_dsc,
+						 guint		   nth_chunk,
+						 GslErrorType	  *error);
+  GslLoader   *next;	/* must be NULL */
+};
+
+void		gsl_loader_register	(GslLoader	*loader);
+GslLoader*	gsl_loader_match	(const gchar	*file_name);
+
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_LOADER_H__ */
diff --git a/flow/gsl/gslmagic.c b/flow/gsl/gslmagic.c
new file mode 100644
index 0000000..29486e3
--- /dev/null
+++ b/flow/gsl/gslmagic.c
@@ -0,0 +1,711 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2000-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include	"gslmagic.h"
+
+#include	"gslcommon.h"
+
+#include	<string.h>
+#include	<unistd.h>
+#include	<errno.h>
+#include	<sys/types.h>
+#include	<stdlib.h>
+#include	<sys/stat.h>
+#include	<fcntl.h>
+
+
+/* --- defines --- */
+#define	BFILE_BSIZE		(768)	/* amount of buffering */
+#define MAX_MAGIC_STRING 	(256)	/* must be < BFILE_BSIZE / 2 */
+
+
+/* --- typedefs & structures  --- */
+typedef struct _Magic Magic;
+typedef struct _BFile BFile;
+struct _BFile
+{
+  gint   fd;
+  guint  file_size;
+  guint8 header[BFILE_BSIZE];
+  guint  offset;
+  guint8 buffer[BFILE_BSIZE];
+};
+
+
+/* --- prototypes --- */
+static Magic*	magic_create		(gchar		*magic_string,
+					 const gchar	*original);
+static gboolean	magic_match_file	(BFile		*bfile,
+					 Magic       	*magics);
+static gboolean	bfile_open		(BFile		*bfile,
+					 const gchar    *file_name);
+static gboolean	bfile_read		(BFile		*bfile,
+					 guint		 offset,
+					 void		*mem,
+					 guint		 n_bytes);
+static void	bfile_close		(BFile		*bfile);
+static guint	bfile_get_size		(BFile		*bfile);
+
+
+/* --- functions --- */
+GslMagic*
+gsl_magic_list_match_file (GslRing     *magic_list,
+			   const gchar *file_name)
+{
+  GslMagic *rmagic = NULL;
+  BFile bfile = { -1, };
+  
+  g_return_val_if_fail (file_name != NULL, NULL);
+  
+  if (bfile_open (&bfile, file_name))
+    {
+      gchar *extension = strrchr (file_name, '.');
+      gint rpriority = G_MAXINT;
+      GslRing *node;
+      
+      /* we do a quick scan by extension first */
+      if (!rmagic && extension)
+	for (node = magic_list; node; node = gsl_ring_walk (magic_list, node))
+	  {
+	    GslMagic *magic = node->data;
+	    
+	    if (!magic->extension
+		|| strcmp (magic->extension, extension) != 0
+		|| rpriority < magic->priority
+		|| (rmagic && rpriority == magic->priority))
+	      continue;
+	    if (magic_match_file (&bfile, magic->match_list))
+	      {
+		rmagic = magic;
+		rpriority = rmagic->priority;
+	      }
+	  }
+      /* then we do a normal walk but skip extension matches */
+      if (!rmagic && extension)
+	for (node = magic_list; node; node = gsl_ring_walk (magic_list, node))
+	  {
+	    GslMagic *magic = node->data;
+	    
+	    if ((magic->extension && strcmp (magic->extension, extension) == 0)
+		|| rpriority < magic->priority
+		|| (rmagic && rpriority == magic->priority))
+	      continue;
+	    if (magic_match_file (&bfile, magic->match_list))
+              {
+		rmagic = magic;
+		rpriority = rmagic->priority;
+	      }
+	  }
+      /* for no extension, we do a full walk */
+      if (!rmagic && !extension)
+	for (node = magic_list; node; node = gsl_ring_walk (magic_list, node))
+	  {
+	    GslMagic *magic = node->data;
+	    
+	    if (rpriority < magic->priority ||
+		(rmagic && rpriority == magic->priority))
+	      continue;
+	    if (magic_match_file (&bfile, magic->match_list))
+	      {
+		rmagic = magic;
+		rpriority = rmagic->priority;
+	      }
+	  }
+      bfile_close (&bfile);
+    }
+  
+  return rmagic;
+}
+
+GslMagic*
+gsl_magic_create (gpointer     data,
+		  gint	       priority,
+		  const gchar *extension,
+		  const gchar *magic_spec)
+{
+  GslMagic *magic;
+  Magic *match_list;
+  gchar *magic_string;
+
+  g_return_val_if_fail (magic_spec != NULL, NULL);
+
+  magic_string = g_strdup (magic_spec);
+  match_list = magic_create (magic_string, magic_spec);
+  g_free (magic_string);
+  if (!match_list)
+    return NULL;
+
+  magic = g_new (GslMagic, 1);
+  magic->data = data;
+  magic->extension = g_strdup (extension);
+  magic->priority = priority;
+  magic->match_list = match_list;
+
+  return magic;
+}
+
+
+/* --- Magic creation/checking --- */
+typedef enum
+{
+  MAGIC_CHECK_ANY,
+  MAGIC_CHECK_INT_EQUAL,
+  MAGIC_CHECK_INT_GREATER,
+  MAGIC_CHECK_INT_SMALLER,
+  MAGIC_CHECK_UINT_GREATER,
+  MAGIC_CHECK_UINT_SMALLER,
+  MAGIC_CHECK_UINT_ZEROS,
+  MAGIC_CHECK_UINT_ONES,
+  MAGIC_CHECK_STRING_EQUAL,
+  MAGIC_CHECK_STRING_GREATER,
+  MAGIC_CHECK_STRING_SMALLER
+} MagicCheckType;
+typedef union
+{
+  gint32  v_int32;
+  guint32 v_uint32;
+  gchar  *v_string;
+} MagicData;
+struct _Magic
+{
+  Magic         *next;
+  gulong         offset;
+  guint          data_size;
+  MagicCheckType magic_check;
+  guint32        data_mask;
+  MagicData	 value;
+  guint          read_string : 1;
+  guint          read_size : 1;
+  guint		 need_swap : 1;
+  guint          cmp_unsigned : 1;
+};
+static const gchar *magic_field_delims = " \t,";
+static const gchar *magic_string_delims = " \t\n\r";
+
+static gboolean
+magic_parse_test (Magic       *magic,
+		  const gchar *string)
+{
+  if (!magic->read_string)
+    {
+      gchar *f = NULL;
+      
+      if (string[0] == '<' || string[0] == '>')
+	{
+	  if (magic->cmp_unsigned)
+	    magic->magic_check = string[0] == '<' ? MAGIC_CHECK_UINT_SMALLER : MAGIC_CHECK_UINT_GREATER;
+	  else
+	    magic->magic_check = string[0] == '<' ? MAGIC_CHECK_INT_SMALLER : MAGIC_CHECK_INT_GREATER;
+	  string += 1;
+	}
+      else if (string[0] == '^' || string[0] == '&')
+	{
+	  magic->magic_check = string[0] == '&' ? MAGIC_CHECK_UINT_ONES : MAGIC_CHECK_UINT_ZEROS;
+	  string += 1;
+	}
+      else if (string[0] == 'x')
+	{
+	  magic->magic_check = MAGIC_CHECK_ANY;
+	  string += 1;
+	}
+      else
+	{
+	  string += string[0] == '=';
+	  magic->magic_check = MAGIC_CHECK_INT_EQUAL;
+	}
+      if (string[0] == '0')
+	magic->value.v_int32 = strtol (string, &f, string[1] == 'x' ? 16 : 8);
+      else
+	magic->value.v_int32 = strtol (string, &f, 10);
+      
+      return *string == 0 || !f || *f == 0;
+    }
+  else
+    {
+      gchar tmp_string[MAX_MAGIC_STRING + 1];
+      guint n = 0;
+      
+      if (string[0] == '<' || string[0] == '>')
+	{
+	  magic->magic_check = string[0] == '<' ? MAGIC_CHECK_STRING_SMALLER : MAGIC_CHECK_STRING_GREATER;
+	  string += 1;
+	}
+      else
+	{
+	  string += string[0] == '=';
+	  magic->magic_check = MAGIC_CHECK_STRING_EQUAL;
+	}
+      while (n < MAX_MAGIC_STRING && string[n] && !strchr (magic_string_delims, string[n]))
+	{
+	  if (string[n] != '\\')
+	    tmp_string[n] = string[n];
+	  else switch ((++string)[n])
+	    {
+	    case '\\':  tmp_string[n] = '\\';	break;
+	    case 't':   tmp_string[n] = '\t';	break;
+	    case 'n':   tmp_string[n] = '\n'; 	break;
+	    case 'r':   tmp_string[n] = '\r'; 	break;
+	    case 'b':   tmp_string[n] = '\b'; 	break;
+	    case 'f':   tmp_string[n] = '\f'; 	break;
+	    case 's':   tmp_string[n] = ' ';  	break;
+	    case 'e':	tmp_string[n] = 27;   	break;
+	    default:
+	      if (string[n] >= '0' && string[n] <= '7')
+		{
+		  tmp_string[n] = string[n] - '0';
+		  if (string[n + 1] >= '0' && string[n + 1] <= '7')
+		    {
+		      string += 1;
+		      tmp_string[n] *= 8;
+		      tmp_string[n] += string[n] - '0';
+		      if (string[n + 1] >= '0' && string[n + 1] <= '7')
+			{
+			  string += 1;
+			  tmp_string[n] *= 8;
+			  tmp_string[n] += string[n] - '0';
+			}
+		    }
+		}
+	      else
+		tmp_string[n] = string[n];
+	      break;
+	    }
+	  n++;
+	}
+      tmp_string[n] = 0;
+      magic->data_size = n;
+      magic->value.v_string = g_strdup (tmp_string);
+
+      return TRUE;
+    }
+}
+
+static gboolean
+magic_parse_type (Magic       *magic,
+		  const gchar *string)
+{
+  gchar *f = NULL;
+
+  if (string[0] == 'u')
+    {
+      string += 1;
+      magic->cmp_unsigned = TRUE;
+    }
+  if (strncmp (string, "byte", 4) == 0)
+    {
+      string += 4;
+      magic->data_size = 1;
+    }
+  else if (strncmp (string, "short", 5) == 0)
+    {
+      string += 5;
+      magic->data_size = 2;
+    }
+  else if (strncmp (string, "leshort", 7) == 0)
+    {
+      string += 7;
+      magic->data_size = 2;
+      magic->need_swap = G_BYTE_ORDER != G_LITTLE_ENDIAN;
+    }
+  else if (strncmp (string, "beshort", 7) == 0)
+    {
+      string += 7;
+      magic->data_size = 2;
+      magic->need_swap = G_BYTE_ORDER != G_BIG_ENDIAN;
+    }
+  else if (strncmp (string, "long", 4) == 0)
+    {
+      string += 4;
+      magic->data_size = 4;
+    }
+  else if (strncmp (string, "lelong", 6) == 0)
+    {
+      string += 6;
+      magic->data_size = 4;
+      magic->need_swap = G_BYTE_ORDER != G_LITTLE_ENDIAN;
+    }
+  else if (strncmp (string, "belong", 6) == 0)
+    {
+      string += 6;
+      magic->data_size = 4;
+      magic->need_swap = G_BYTE_ORDER != G_BIG_ENDIAN;
+    }
+#if 0
+  else if (strncmp (string, "size", 4) == 0)
+    {
+      string += 4;
+      magic->data_size = 4;
+      magic->read_size = TRUE;
+      magic->cmp_unsigned = TRUE;
+    }
+#endif
+  else if (strncmp (string, "string", 6) == 0)
+    {
+      string += 6;
+      magic->data_size = 0;
+      magic->read_string = TRUE;
+    }
+  if (string[0] == '&')
+    {
+      string += 1;
+      if (string[0] == '0')
+	magic->data_mask = strtol (string, &f, string[1] == 'x' ? 16 : 8);
+      else
+	magic->data_mask = strtol (string, &f, 10);
+      if (f && *f != 0)
+	return FALSE;
+      while (*string)
+	string++;
+    }
+  else
+    magic->data_mask = 0xffffffff;
+
+  return *string == 0;
+}
+
+static gboolean
+magic_parse_offset (Magic *magic,
+		    gchar *string)
+{
+  gchar *f = NULL;
+  
+  if (string[0] == '0')
+    magic->offset = strtol (string, &f, string[1] == 'x' ? 16 : 8);
+  else
+    magic->offset = strtol (string, &f, 10);
+
+  return !f || *f == 0;
+}
+
+static Magic*
+magic_create (gchar       *magic_string,
+	      const gchar *original)
+#define SKIP_CLEAN(s)	{ while (*s && !strchr(magic_field_delims, *s)) s++; \
+                          while (*s && strchr(magic_field_delims, *s)) \
+                            *(s++)=0;}
+{
+  Magic *magics = NULL;
+  gchar *p = magic_string;
+  
+  while (p && *p)
+    {
+      gchar *next_line;
+      
+      if (*p == '#' || *p == '\n')
+	{
+	  next_line = strchr (p, '\n');
+	  if (next_line)
+	    next_line++;
+	}
+      else
+	{
+	  Magic *tmp = magics;
+	  
+	  magics = g_new0 (Magic, 1);
+	  magics->next = tmp;
+	  
+	  magic_string = p;
+	  SKIP_CLEAN (p);
+	  if (!magic_parse_offset (magics, magic_string))
+	    {
+	      g_warning ("unable to parse magic offset \"%s\" from \"%s\"", magic_string, original);
+	      return NULL;
+	    }
+	  magic_string = p;
+	  SKIP_CLEAN (p);
+	  if (!magic_parse_type (magics, magic_string))
+	    {
+	      g_warning ("unable to parse magic type \"%s\" from \"%s\"", magic_string, original);
+	      return NULL;
+	    }
+          magic_string = p;
+	  next_line = strchr (magic_string, '\n');
+	  if (next_line)
+	    *(next_line++) = 0;
+	  if (!magics->read_string)
+	    SKIP_CLEAN (p);
+	  if (!magic_parse_test (magics, magic_string))
+	    {
+	      g_warning ("unable to parse magic test \"%s\" from \"%s\"", magic_string, original);
+	      return NULL;
+	    }
+	}
+      p = next_line;
+    }
+  
+  return magics;
+}
+
+static gboolean
+magic_check_data (Magic     *magic,
+		  MagicData *data)
+{
+  gint cmp = 0;
+
+  switch (magic->magic_check)
+    {
+      guint l;
+    case MAGIC_CHECK_ANY:
+      cmp = 1;
+      break;
+    case MAGIC_CHECK_INT_EQUAL:
+      data->v_int32 &= magic->data_mask;
+      cmp = data->v_int32 == magic->value.v_int32;
+      break;
+    case MAGIC_CHECK_INT_GREATER:
+      data->v_int32 &= magic->data_mask;
+      cmp = data->v_int32 > magic->value.v_int32;
+      break;
+    case MAGIC_CHECK_INT_SMALLER:
+      data->v_int32 &= magic->data_mask;
+      cmp = data->v_int32 < magic->value.v_int32;
+      break;
+    case MAGIC_CHECK_UINT_GREATER:
+      data->v_uint32 &= magic->data_mask;
+      cmp = data->v_uint32 > magic->value.v_uint32;
+      break;
+    case MAGIC_CHECK_UINT_SMALLER:
+      data->v_uint32 &= magic->data_mask;
+      cmp = data->v_uint32 < magic->value.v_uint32;
+      break;
+    case MAGIC_CHECK_UINT_ZEROS:
+      data->v_uint32 &= magic->data_mask;
+      cmp = (data->v_int32 & magic->value.v_int32) == 0;
+      break;
+    case MAGIC_CHECK_UINT_ONES:
+      data->v_uint32 &= magic->data_mask;
+      cmp = (data->v_int32 & magic->value.v_int32) == magic->value.v_int32;
+      break;
+    case MAGIC_CHECK_STRING_EQUAL:
+      l = magic->data_size < 1 ? strlen (data->v_string) : magic->data_size;
+      cmp = strncmp (data->v_string, magic->value.v_string, l) == 0;
+      break;
+    case MAGIC_CHECK_STRING_GREATER:
+      l = magic->data_size < 1 ? strlen (data->v_string) : magic->data_size;
+      cmp = strncmp (data->v_string, magic->value.v_string, l) > 0;
+      break;
+    case MAGIC_CHECK_STRING_SMALLER:
+      l = magic->data_size < 1 ? strlen (data->v_string) : magic->data_size;
+      cmp = strncmp (data->v_string, magic->value.v_string, l) < 0;
+      break;
+    }
+
+  return cmp > 0;
+}
+
+static inline gboolean
+magic_read_data (BFile     *bfile,
+		 Magic     *magic,
+		 MagicData *data)
+{
+  guint file_size = bfile_get_size (bfile);
+
+  if (magic->read_size)
+    data->v_uint32 = file_size;
+  else if (magic->read_string)
+    {
+      guint l = magic->data_size;
+      
+      if (l < 1 || l > MAX_MAGIC_STRING)
+	l = MIN (MAX_MAGIC_STRING, file_size - magic->offset);
+      if (!bfile_read (bfile, magic->offset, data->v_string, l))
+	return FALSE;
+      data->v_string[MAX (l, 0)] = 0;
+    }
+  else
+    {
+      if (magic->data_size == 4)
+	{
+	  guint32 uint32 = 0;
+
+	  if (!bfile_read (bfile, magic->offset, &uint32, 4))
+	    return FALSE;
+	  if (magic->need_swap)
+	    data->v_uint32 = GUINT32_SWAP_LE_BE (uint32);
+	  else
+	    data->v_uint32 = uint32;
+	}
+      else if (magic->data_size == 2)
+	{
+	  guint16 uint16 = 0;
+
+          if (!bfile_read (bfile, magic->offset, &uint16, 2))
+	    return FALSE;
+	  if (magic->need_swap)
+	    uint16 = GUINT16_SWAP_LE_BE (uint16);
+	  if (magic->cmp_unsigned)
+	    data->v_uint32 = uint16;
+	  else
+	    data->v_int32 = (signed) uint16;
+	}
+      else if (magic->data_size == 1)
+	{
+	  guint8 uint8;
+
+          if (!bfile_read (bfile, magic->offset, &uint8, 1))
+	    return FALSE;
+	  if (magic->cmp_unsigned)
+	    data->v_uint32 = uint8;
+	  else
+	    data->v_int32 = (signed) uint8;
+	}
+      else
+	g_assert_not_reached ();
+    }
+
+  return TRUE;
+}
+
+static gboolean
+magic_match_file (BFile *bfile,
+		  Magic *magics)
+{
+  g_return_val_if_fail (bfile != NULL, FALSE);
+  g_return_val_if_fail (magics != NULL, FALSE);
+
+  do
+    {
+      gchar data_string[MAX_MAGIC_STRING + 1];
+      MagicData data;
+      
+      if (magics->read_string)
+	data.v_string = data_string;
+      else
+	data.v_uint32 = 0;
+      
+      if (!magic_read_data (bfile, magics, &data) ||
+	  !magic_check_data (magics, &data))
+	return FALSE;
+      magics = magics->next;
+    }
+  while (magics);
+
+  return TRUE;
+}
+
+
+/* --- buffered file, optimized for magic checks --- */
+static gboolean
+bfile_open (BFile       *bfile,
+	    const gchar *file_name)
+{
+  struct stat buf = { 0, };
+  gint ret;
+
+  g_return_val_if_fail (bfile != NULL, FALSE);
+  g_return_val_if_fail (bfile->fd < 0, FALSE);
+  g_return_val_if_fail (file_name != NULL, FALSE);
+
+  bfile->fd = open (file_name, O_RDONLY);
+  if (bfile->fd < 0)
+    return FALSE;
+
+  do
+    ret = fstat (bfile->fd, &buf);
+  while (ret < 0 && errno == EINTR);
+  if (ret < 0)
+    {
+      bfile_close (bfile);
+      return FALSE;
+    }
+  bfile->file_size = buf.st_size;
+
+  do
+    ret = read (bfile->fd, bfile->header, BFILE_BSIZE);
+  while (ret < 0 && errno == EINTR);
+  if (ret < 0)
+    {
+      bfile_close (bfile);
+      return FALSE;
+    }
+
+  bfile->offset = 0;
+  memcpy (bfile->buffer, bfile->header, BFILE_BSIZE);
+
+  return TRUE;
+}
+
+static gboolean
+bfile_read (BFile *bfile,
+	    guint  offset,
+	    void  *mem,
+	    guint  n_bytes)
+{
+  guint end = offset + n_bytes;
+  gint ret;
+
+  g_return_val_if_fail (bfile != NULL, FALSE);
+  g_return_val_if_fail (n_bytes < BFILE_BSIZE / 2, FALSE);
+
+  if (end > bfile->file_size || bfile->fd < 0)
+    return FALSE;
+
+  if (end < BFILE_BSIZE)
+    {
+      memcpy (mem, bfile->header + offset, n_bytes);
+      return TRUE;
+    }
+  if (offset >= bfile->offset && end < bfile->offset + BFILE_BSIZE)
+    {
+      memcpy (mem, bfile->buffer + offset - bfile->offset, n_bytes);
+      return TRUE;
+    }
+
+  bfile->offset = offset - BFILE_BSIZE / 8;
+  do
+    ret = lseek (bfile->fd, bfile->offset, SEEK_SET);
+  while (ret < 0 && errno == EINTR);
+  if (ret < 0)
+    {
+      bfile_close (bfile);
+      return FALSE;
+    }
+  do
+    ret = read (bfile->fd, bfile->buffer, BFILE_BSIZE);
+  while (ret < 0 && errno == EINTR);
+  if (ret < 0)
+    {
+      bfile_close (bfile);
+      return FALSE;
+    }
+  if (offset >= bfile->offset && end < bfile->offset + BFILE_BSIZE)
+    {
+      memcpy (mem, bfile->buffer + offset - bfile->offset, n_bytes);
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static guint
+bfile_get_size (BFile *bfile)
+{
+  g_return_val_if_fail (bfile != NULL, 0);
+
+  return bfile->fd >= 0 ? bfile->file_size : 0;
+}
+
+static void
+bfile_close (BFile *bfile)
+{
+  g_return_if_fail (bfile != NULL);
+
+  if (bfile->fd >= 0)
+    close (bfile->fd);
+  bfile->fd = -1;
+}
diff --git a/flow/gsl/gslmagic.h b/flow/gsl/gslmagic.h
new file mode 100644
index 0000000..41961bd
--- /dev/null
+++ b/flow/gsl/gslmagic.h
@@ -0,0 +1,72 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2000-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_MAGIC_H__
+#define __GSL_MAGIC_H__
+
+#include	<gsl/gsldefs.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+/* --- structures --- */
+struct _GslMagic
+{
+  gpointer data;
+  gchar   *extension;
+
+  /*< private >*/
+  gint     priority;
+  gpointer match_list;
+};
+
+
+/* match entity with:
+ * prefix,
+ * extension,
+ * magic_spec
+ *
+ * where prefix has absolute preference, and extension is just
+ * a _hint_ for magic_spec match order, unless magic_spec==NULL
+ *
+ * no prefix for save handlers. (?) just extension matches.
+ *
+ * need pre-parse functionality, to figure name and type of a
+ * file's contents.
+ */
+
+
+/* --- prototypes --- */
+GslMagic*	gsl_magic_create		(gpointer	 data,
+						 gint		 priority,
+						 const gchar	*extension,
+						 const gchar	*magic_spec);
+GslMagic*	gsl_magic_list_match_file	(GslRing	*magic_list,
+						 const gchar    *file_name);
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_MAGIC_H__ */
diff --git a/flow/gsl/gslmakefile.inc b/flow/gsl/gslmakefile.inc
new file mode 100644
index 0000000..9787b7d
--- /dev/null
+++ b/flow/gsl/gslmakefile.inc
@@ -0,0 +1,87 @@
+# this makefile defines:
+#
+# GSL_C_SRC		C source files which need to be added to *_SOURCES
+# GSL_NOINST_PROGS	GSL test programs, needs to be added to noinst_PROGRAMS
+#
+# this makefile supports:
+#
+# GSL_progs_ldadd	add link options to this varibale, which are required
+#			to link GSL_NOINST_PROGS targets
+# gslincludedir		directory to install public headers into if not empty
+#
+# this makefile introduces:
+#
+# gsltestoutput:	make target to generate a sample set of test data
+
+# make sure gslincludedir= is defined
+# GSL targets
+GSL_H_SRC     =	gslcommon.h gsldatacache.h gsldatahandle.h gsldefs.h \
+		gslloader.h gslmath.h gslfilter.h gsldatautils.h gsldatahandle-vorbis.h \
+		gslconvert.h gslfft.h gslieee754.h gslsignal.h gslmagic.h \
+		gslengine.h gslwaveosc.h gslwavechunk.h gsldatahandle-mad.h \
+		gslosctable.h gsloscillator.h
+GSL_C_SRC     =	gsldatacache.c gsldatahandle.c gslwavechunk.c gsldatahandle-vorbis.c \
+		gslmath.c gslfilter.c gslcommon.c gsldatautils.c gslmagic.c \
+		gslloader-wav.c gslloader-gslwave.c gslloader-mad.c gslloader-oggvorbis.c \
+		gslconvert.c gslfft.c gslsignal.c gslloader.c gslwaveosc.c \
+		gslengine.c gsloputil.c gslopmaster.c gslopschedule.c gsldatahandle-mad.c \
+		gslosctable.c gsloscillator.c
+GSL_EXTRA_SRC =	gslconfig.h gsloputil.h gslopmaster.h gslopnode.h \
+		gslopschedule.h gslincluder.c gslwaveosc-aux.c gsloscillator-aux.c
+GSL_EXTRA_DAT = gsl.gnuplot gsl-mplan.txt gslarrows gslwave.header gslglib.c gslglib.h gsl-fftgen.pl
+EXTRA_DIST   +=	$(GSL_H_SRC) $(GSL_EXTRA_SRC) $(GSL_EXTRA_DAT)
+
+GSL_NOINST_PROGS = gslwchunk gsltests gslffttest
+gslwchunk_SOURCES = gslwchunk.c
+gslwchunk_LDADD = $(GSL_progs_ldadd)
+gslwchunk_LDFLAGS = $(USE_THREADS)
+gsltests_SOURCES = gsltests.c
+gsltests_LDADD = $(GSL_progs_ldadd)
+gsltests_LDFLAGS = $(USE_THREADS)
+gslffttest_SOURCES = gslffttest.c
+gslffttest_LDADD = $(GSL_progs_ldadd)
+gslffttest_LDFLAGS = $(USE_THREADS)
+
+$(srcdir)/gslfft.c: $(srcdir)/gsl-fftgen.pl $(srcdir)/gsl-fftconf.sh
+	cd $(srcdir) && ./gsl-fftconf.sh 'perl ./gsl-fftgen.pl' \"gslfft.h\" >gslfft.c
+MAINTAINERCLEANFILES += gslfft.c
+
+$(srcdir)/gslwchunk.c: gslconfig.h
+$(srcdir)/gsltests.c: gslconfig.h
+$(srcdir)/gslffttest.c: gslconfig.h
+# $(OBJECTS): gslconfig.h
+
+gsl_public_HEADERS = $(GSL_H_SRC) gslconfig.h
+gsl_publicdir = $(gslincludedir)
+
+.PHONY:	gsltestoutput 
+
+gsltestoutput:
+	@./gsltests blp     7 0.3		0.1211
+	@./gsltests bhp    12 1.8332		0.1033
+	@./gsltests bbp    14 0.5 0.6		0.1033
+	@./gsltests bbs    12 1.5 1.6		0.2
+	@./gsltests t1l     7 0.3		0.0125
+	@./gsltests t1h     8 1.8332		0.1033
+	@./gsltests t1p     6 0.5 0.6		0.1033
+	@./gsltests t1s     8 1.4 1.5		0.25
+	@./gsltests t2l    13 0.1	1.1	0.176
+	@./gsltests t2h    10 1.14	1.2	0.0763
+	@./gsltests t2p    14 0.7 0.8	1.3	0.0763
+	@./gsltests t2p    10 0.9 1.2	1.4	0.15
+	@./gsltests t2s    10 0.9 1.2	1.1	0.15
+	@echo -n "plot [0:pi] [-96:1]"
+	@echo -n " dB(BL7(Z(x))),"
+	@echo -n " dB(BH12(Z(x))),"
+	@echo -n " dB(BP14(Z(x))),"
+	@echo -n " dB(BS12(Z(x))),"
+	@echo -n " dB(T1L7(Z(x))),"
+	@echo -n " dB(T1H8(Z(x))),"
+	@echo -n " dB(T1P6(Z(x))),"
+	@echo -n " dB(T1S8(Z(x))),"
+	@echo -n " dB(T2L13(Z(x))),"
+	@echo -n " dB(T2H10(Z(x))),"
+	@echo -n " dB(T2P14(Z(x))),"
+	@echo -n " dB(T2P10(Z(x))),"
+	@echo -n " dB(T2S10(Z(x))),"
+	@echo " -3"
diff --git a/flow/gsl/gslmath.c b/flow/gsl/gslmath.c
new file mode 100644
index 0000000..97ac675
--- /dev/null
+++ b/flow/gsl/gslmath.c
@@ -0,0 +1,1085 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Stefan Westerfeld and Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslmath.h"
+
+#include <string.h>
+#include <stdio.h>
+
+
+#define RING_BUFFER_LENGTH	(16)
+#define	PRINTF_DIGITS		"1270"
+#define	FLOAT_STRING_SIZE	(2048)
+
+
+/* factorization constants: 2^(1/12), ln(2^(1/12)) and 2^(1/(12*6))
+ * retrived with:
+ #include <stl.h>
+ #include <complex.h>
+ typedef long double ld;
+ 
+ int main (void)
+ {
+ ld r, l;
+ 
+ cout.precision(256);
+ 
+ r = pow ((ld) 2, (ld) 1 / (ld) 12);
+ cout << "2^(1/12) =\n";
+ cout << "2^" << (ld) 1 / (ld) 12 << " =\n";
+ cout << r << "\n";
+ 
+ l = log (r);
+ cout << "ln(2^(1/12)) =\n";
+ cout << "ln(" << r << ") =\n";
+ cout << l << "\n";
+ 
+ r = pow ((ld) 2, (ld) 1 / (ld) 72);
+ cout << "2^(1/72) =\n";
+ cout << "2^" << (ld) 1 / (ld) 72 << " =\n";
+ cout << r << "\n";
+ 
+ return 0;
+ }
+*/
+
+
+/* --- prototypes --- */
+static void		zrhqr	(double a[], int m, double rtr[], double rti[]);
+static double		rf	(double x, double y, double z);
+static double		ellf	(double phi, double ak);
+static void		sncndn	(double uu, double emmc, double *sn_p, double *cn_p, double *dn_p);
+static void		sncndnC	(GslComplex uu, GslComplex emmc, GslComplex *sn_p, GslComplex *cn_p, GslComplex *dn_p);
+static GslComplex	rfC	(GslComplex x, GslComplex y, GslComplex z);
+
+
+/* --- functions --- */
+static inline char*
+pretty_print_double (char  *str,
+		     double d)
+{
+  char *s= str;
+  
+  sprintf (s, "%."PRINTF_DIGITS"f", d);
+  while (*s) s++;
+  while (s[-1] == '0' && s[-2] != '.')
+    s--;
+  *s = 0;
+  return s;
+}
+
+char*
+gsl_complex_list (unsigned int n_points,
+		  GslComplex  *points,
+		  const char  *indent)
+{
+  static unsigned int rbi = 0;
+  static char* rbuffer[RING_BUFFER_LENGTH] = { NULL, };
+  char *s, *tbuffer = g_newa (char, (FLOAT_STRING_SIZE * 2 * n_points));
+  unsigned int i;
+  
+  rbi++; if (rbi >= RING_BUFFER_LENGTH) rbi -= RING_BUFFER_LENGTH;
+  if (rbuffer[rbi] != NULL)
+    g_free (rbuffer[rbi]);
+  s = tbuffer;
+  for (i = 0; i < n_points; i++)
+    {
+      *s = 0;
+      if (indent)
+	strcat (s, indent);
+      while (*s) s++;
+      s = pretty_print_double (s, points[i].re);
+      *s++ = ' ';
+      s = pretty_print_double (s, points[i].im);
+      *s++ = '\n';
+    }
+  *s++ = 0;
+  rbuffer[rbi] = g_strdup (tbuffer);
+  return rbuffer[rbi];
+}
+
+char*
+gsl_complex_str (GslComplex c)
+{
+  static unsigned int rbi = 0;
+  static char* rbuffer[RING_BUFFER_LENGTH] = { NULL, };
+  char *s, tbuffer[FLOAT_STRING_SIZE * 2];
+  
+  rbi++; if (rbi >= RING_BUFFER_LENGTH) rbi -= RING_BUFFER_LENGTH;
+  if (rbuffer[rbi] != NULL)
+    g_free (rbuffer[rbi]);
+  s = tbuffer;
+  *s++ = '{';
+  s = pretty_print_double (s, c.re);
+  *s++ = ',';
+  *s++ = ' ';
+  s = pretty_print_double (s, c.im);
+  *s++ = '}';
+  *s++ = 0;
+  rbuffer[rbi] = g_strdup (tbuffer);
+  return rbuffer[rbi];
+}
+
+char*
+gsl_poly_str (unsigned int degree,
+	      double      *a,
+	      const char  *var)
+{
+  static unsigned int rbi = 0;
+  static char* rbuffer[RING_BUFFER_LENGTH] = { NULL, };
+  char *s, *tbuffer = g_newa (char, degree * FLOAT_STRING_SIZE);
+  unsigned int i;
+  
+  if (!var)
+    var = "x";
+  rbi++; if (rbi >= RING_BUFFER_LENGTH) rbi -= RING_BUFFER_LENGTH;
+  if (rbuffer[rbi] != NULL)
+    g_free (rbuffer[rbi]);
+  s = tbuffer;
+  *s++ = '(';
+  s = pretty_print_double (s, a[0]);
+  for (i = 1; i <= degree; i++)
+    {
+      *s++ = '+';
+      *s = 0; strcat (s, var); while (*s) s++;
+      *s++ = '*';
+      *s++ = '(';
+      s = pretty_print_double (s, a[i]);
+    }
+  while (i--)
+    *s++ = ')';
+  *s++ = 0;
+  rbuffer[rbi] = g_strdup (tbuffer);
+  return rbuffer[rbi];
+}
+
+char*
+gsl_poly_str1 (unsigned int degree,
+	       double      *a,
+	       const char  *var)
+{
+  static unsigned int rbi = 0;
+  static char* rbuffer[RING_BUFFER_LENGTH] = { NULL, };
+  char *s, *tbuffer = g_newa (char, degree * FLOAT_STRING_SIZE);
+  unsigned int i, need_plus = 0;
+  
+  if (!var)
+    var = "x";
+  rbi++; if (rbi >= RING_BUFFER_LENGTH) rbi -= RING_BUFFER_LENGTH;
+  if (rbuffer[rbi] != NULL)
+    g_free (rbuffer[rbi]);
+  s = tbuffer;
+  *s++ = '(';
+  if (a[0] != 0.0)
+    {
+      s = pretty_print_double (s, a[0]);
+      need_plus = 1;
+    }
+  for (i = 1; i <= degree; i++)
+    {
+      if (a[i] == 0.0)
+	continue;
+      if (need_plus)
+	{
+	  *s++ = ' ';
+	  *s++ = '+';
+	  *s++ = ' ';
+	}
+      if (a[i] != 1.0)
+	{
+	  s = pretty_print_double (s, a[i]);
+	  *s++ = '*';
+	}
+      *s = 0;
+      strcat (s, var);
+      while (*s) s++;
+      if (i > 1)
+	{
+	  *s++ = '*';
+	  *s++ = '*';
+	  sprintf (s, "%u", i);
+	  while (*s) s++;
+	}
+      need_plus = 1;
+    }
+  *s++ = ')';
+  *s++ = 0;
+  rbuffer[rbi] = g_strdup (tbuffer);
+  return rbuffer[rbi];
+}
+
+void
+gsl_complex_gnuplot (const char  *file_name,
+		     unsigned int n_points,
+		     GslComplex  *points)
+{
+  FILE *fout = fopen (file_name, "w");
+  
+  fputs (gsl_complex_list (n_points, points, ""), fout);
+  fclose (fout);
+}
+
+double
+gsl_temp_freq (double kammer_freq,
+	       int    halftone_delta)
+{
+  double factor;
+  
+  factor = pow (GSL_2_POW_1_DIV_12, halftone_delta);
+  
+  return kammer_freq * factor;
+}
+
+void
+gsl_poly_from_re_roots (unsigned int degree,
+			double      *a,
+			GslComplex  *roots)
+{
+  unsigned int i;
+  
+  /* initialize polynomial */
+  a[1] = 1;
+  a[0] = -roots[0].re;
+  /* monomial factor multiplication */
+  for (i = 1; i < degree; i++)
+    {
+      unsigned int j;
+      
+      a[i + 1] = a[i];
+      for (j = i; j >= 1; j--)
+	a[j] = a[j - 1] - a[j] * roots[i].re;
+      a[0] *= -roots[i].re;
+    }
+}
+
+void
+gsl_cpoly_from_roots (unsigned int degree,
+		      GslComplex  *c,
+		      GslComplex  *roots)
+{
+  unsigned int i;
+  
+  /* initialize polynomial */
+  c[1].re = 1;
+  c[1].im = 0;
+  c[0].re = -roots[0].re;
+  c[0].im = -roots[0].im;
+  /* monomial factor multiplication */
+  for (i = 1; i < degree; i++)
+    {
+      GslComplex r = gsl_complex (-roots[i].re, -roots[i].im);
+      unsigned int j;
+      
+      c[i + 1] = c[i];
+      for (j = i; j >= 1; j--)
+	c[j] = gsl_complex_add (c[j - 1], gsl_complex_mul (c[j], r));
+      c[0] = gsl_complex_mul (c[0], r);
+    }
+}
+
+void
+gsl_poly_complex_roots (unsigned int degree,
+			double      *a,		/* [0..degree] (degree+1 elements) */
+			GslComplex  *roots)	/* [degree] */
+{
+  double *roots_re = g_newa (double, 1 + degree);
+  double *roots_im = g_newa (double, 1 + degree);
+  unsigned int i;
+  
+  zrhqr (a, degree, roots_re, roots_im);
+  for (i = 0; i < degree; i++)
+    {
+      roots[i].re = roots_re[1 + i];
+      roots[i].im = roots_im[1 + i];
+    }
+}
+
+double
+gsl_ellip_rf (double x,
+	      double y,
+	      double z)
+{
+  return rf (x, y, z);
+}
+
+double
+gsl_ellip_F (double phi,
+	     double ak)
+{
+  return ellf (phi, ak);
+}
+
+double
+gsl_ellip_sn (double u,
+	      double emmc)
+{
+  double sn;
+  
+  sncndn (u, emmc, &sn, NULL, NULL);
+  return sn;
+}
+
+double
+gsl_ellip_asn (double y,
+	       double emmc)
+{
+  return y * rf (1.0 - y * y, 1.0 - y * y * (1.0 - emmc), 1.0);
+}
+
+GslComplex
+gsl_complex_ellip_asn (GslComplex y,
+		       GslComplex emmc)
+{
+  return gsl_complex_mul (y,
+			  rfC (gsl_complex_sub (gsl_complex (1.0, 0),
+						gsl_complex_mul (y, y)),
+			       gsl_complex_sub (gsl_complex (1.0, 0),
+						gsl_complex_mul3 (y, y, gsl_complex_sub (gsl_complex (1.0, 0),
+											 emmc))),
+			       gsl_complex (1.0, 0)));
+}
+
+GslComplex
+gsl_complex_ellip_sn (GslComplex u,
+		      GslComplex emmc)
+{
+  GslComplex sn;
+  
+  sncndnC (u, emmc, &sn, NULL, NULL);
+  return sn;
+}
+
+double
+gsl_bit_depth_epsilon (guint n_bits)
+{
+  /* epsilon for various bit depths, based on significance of one bit,
+   * minus fudge. created with:
+   * { echo "scale=40"; for i in `seq 1 32` ; do echo "1/2^$i - 10^-($i+1)" ; done } | bc | sed 's/$/,/'
+   */
+  static const double bit_epsilons[] = {
+    .4900000000000000000000000000000000000000,
+    .2490000000000000000000000000000000000000,
+    .1249000000000000000000000000000000000000,
+    .0624900000000000000000000000000000000000,
+    .0312490000000000000000000000000000000000,
+    .0156249000000000000000000000000000000000,
+    .0078124900000000000000000000000000000000,
+    .0039062490000000000000000000000000000000,
+    .0019531249000000000000000000000000000000,
+    .0009765624900000000000000000000000000000,
+    .0004882812490000000000000000000000000000,
+    .0002441406249000000000000000000000000000,
+    .0001220703124900000000000000000000000000,
+    .0000610351562490000000000000000000000000,
+    .0000305175781249000000000000000000000000,
+    .0000152587890624900000000000000000000000,
+    .0000076293945312490000000000000000000000,
+    .0000038146972656249000000000000000000000,
+    .0000019073486328124900000000000000000000,
+    .0000009536743164062490000000000000000000,
+    .0000004768371582031249000000000000000000,
+    .0000002384185791015624900000000000000000,
+    .0000001192092895507812490000000000000000,
+    .0000000596046447753906249000000000000000,
+    .0000000298023223876953124900000000000000,
+    .0000000149011611938476562490000000000000,
+    .0000000074505805969238281249000000000000,
+    .0000000037252902984619140624900000000000,
+    .0000000018626451492309570312490000000000,
+    .0000000009313225746154785156249000000000,
+    .0000000004656612873077392578124900000000,
+    .0000000002328306436538696289062490000000,
+  };
+
+  return bit_epsilons[CLAMP (n_bits, 1, 32) - 1];
+}
+
+
+/* --- Numerical Receipes --- */
+#define	gsl_complex_rmul(scale, c)	gsl_complex_scale (c, scale)
+#define	ONE				gsl_complex (1.0, 0)
+#define	SIGN(a,b)	((b) >= 0.0 ? fabs (a) : -fabs(a))
+static inline int IMAX (int i1, int i2) { return i1 > i2 ? i1 : i2; }
+static inline double DMIN (double d1, double d2) { return d1 < d2 ? d1 : d2; }
+static inline double DMAX (double d1, double d2) { return d1 > d2 ? d1 : d2; }
+static inline double DSQR (double d) { return d == 0.0 ? 0.0 : d * d; }
+#define nrerror(error)	g_error ("NR-ERROR: %s", (error))
+static inline double* vector (long nl, long nh)
+     /* allocate a vector with subscript range v[nl..nh] */
+{
+  double *v = g_new (double, nh - nl + 1 + 1);
+  return v - nl + 1;
+}
+static inline void free_vector (double *v, long nl, long nh)
+{
+  g_free (v + nl - 1);
+}
+static inline double** matrix (long nrl, long nrh, long ncl, long nch)
+     /* allocate a matrix with subscript range m[nrl..nrh][ncl..nch] */
+{
+  long i, nrow = nrh - nrl + 1, ncol = nch - ncl + 1;
+  double **m = g_new (double*, nrow + 1);
+  m += 1;
+  m -= nrl;
+  m[nrl] = g_new (double, nrow * ncol + 1);
+  m[nrl] += 1;
+  m[nrl] -= ncl;
+  for (i = nrl + 1; i <= nrh; i++)
+    m[i] = m[i - 1] + ncol;
+  return m;
+}
+static inline void free_matrix (double **m, long nrl, long nrh, long ncl, long nch)
+{
+  g_free (m[nrl] + ncl - 1);
+  g_free (m + nrl - 1);
+}
+
+static void
+poldiv (double u[], int n, double v[], int nv, double q[], double r[])
+     /* Given the n+1 coefficients of a polynomial of degree n in u[0..n], and the nv+1 coefficients
+	of another polynomial of degree nv in v[0..nv], divide the polynomial u by the polynomial
+	v ("u"/"v") giving a quotient polynomial whose coefficients are returned in q[0..n], and a
+	remainder polynomial whose coefficients are returned in r[0..n]. The elements r[nv..n]
+	and q[n-nv+1..n] are returned as zero. */
+{
+  int k,j;
+  
+  for (j=0;j<=n;j++) {
+    r[j]=u[j];
+    q[j]=0.0;
+  }for (k=n-nv;k>=0;k--) {
+    q[k]=r[nv+k]/v[nv];
+    for (j=nv+k-1;j>=k;j--) r[j] -= q[k]*v[j-k];
+  }for (j=nv;j<=n;j++) r[j]=0.0;
+}
+
+#define	MAX_ITER_BASE	9	/* TIMJ: was 3 */
+#define	MAX_ITER_FAC	20	/* TIMJ: was 10 */
+static void
+hqr (double **a, int n, double wr[], double wi[])
+     /* Finds all eigenvalues of an upper Hessenberg matrix a[1..n][1..n]. On input a can be
+	exactly as output from elmhes §11.5; on output it is destroyed. The real and imaginary parts
+	of the eigenvalues are returned in wr[1..n] and wi[1..n], respectively. */
+{
+  int nn,m,l,k,j,its,i,mmin;
+  double z,y,x,w,v,u,t,s,r,q,p,anorm;
+  r=q=p=0; /* TIMJ: silence compiler */
+  
+  anorm=0.0;                                  /* Compute matrix norm for possible use in lo- */
+  for (i=1;i<=n;i++)                          /* cating single small subdiagonal element. */
+    for (j=IMAX (i-1,1);j<=n;j++)
+      anorm += fabs (a[i][j]);
+  nn=n;
+  t=0.0;                                      /* Gets changed only by an exceptional shift. */
+  while (nn >= 1) {                           /* Begin search for next eigenvalue. */
+    its=0;
+    do {for (l=nn;l>=2;l--) {                 /* Begin iteration: look for single small subdi- */
+      s=fabs (a[l-1][l-1])+fabs (a[l][l]);      /* agonal element. */
+      if (s == 0.0) s=anorm;
+      if ((double)(fabs (a[l][l-1]) + s) == s) break;
+    }
+    x=a[nn][nn];
+    if (l == nn) {                    /* One root found. */
+      wr[nn]=x+t;
+      wi[nn--]=0.0;
+    } else {
+      y=a[nn-1][nn-1];
+      w=a[nn][nn-1]*a[nn-1][nn];
+      if (l == (nn-1)) {            /* Two roots found... */
+	p=0.5*(y-x);
+	q=p*p+w;
+	z=sqrt (fabs (q));
+	x += t;
+	if (q >= 0.0) {           /* ...a real pair. */
+	  z=p+SIGN (z,p);
+	  wr[nn-1]=wr[nn]=x+z;
+	  if (z) wr[nn]=x-w/z;
+	  wi[nn-1]=wi[nn]=0.0;
+	} else {                  /* ...a complex pair. */
+	  wr[nn-1]=wr[nn]=x+p;
+	  wi[nn-1]= -(wi[nn]=z);
+	}
+	nn -= 2;
+      } else {                      /* No roots found. Continue iteration. */
+	if (its == MAX_ITER_BASE * MAX_ITER_FAC)
+	  nrerror ("Too many iterations in hqr");
+	if (its && !(its%MAX_ITER_FAC)) {                /* Form exceptional shift. */
+	  t += x;
+	  for (i=1;i<=nn;i++) a[i][i] -= x;
+	  s=fabs (a[nn][nn-1])+fabs (a[nn-1][nn-2]);
+	  y=x=0.75*s;
+	  w = -0.4375*s*s;
+	}
+	++its;
+	for (m=(nn-2);m>=l;m--) {                    /* Form shift and then look for */
+	  z=a[m][m];                                 /* 2 consecutive small sub- */
+	  r=x-z;                                     /* diagonal elements. */
+	  s=y-z;
+	  p=(r*s-w)/a[m+1][m]+a[m][m+1];           /* Equation (11.6.23). */
+	  q=a[m+1][m+1]-z-r-s;
+	  r=a[m+2][m+1];
+	  s=fabs (p)+fabs (q)+fabs (r);             /* Scale to prevent overflow or */
+	  p /= s;                                    /* underflow. */
+	  q /= s;
+	  r /= s;
+	  if (m == l) break;
+	  u=fabs (a[m][m-1])*(fabs (q)+fabs (r));
+	  v=fabs (p)*(fabs (a[m-1][m-1])+fabs (z)+fabs (a[m+1][m+1]));
+	  if ((double)(u+v) == v)
+	    break;          /* Equation (11.6.26). */
+	}
+	for (i=m+2;i<=nn;i++) {
+	  a[i][i-2]=0.0;
+	  if (i != (m+2))
+	    a[i][i-3]=0.0;
+	}
+	for (k=m;k<=nn-1;k++) {
+	  /* Double QR step on rows l to nn and columns m to nn. */
+	  if (k != m) {
+	    p=a[k][k-1];                      /* Begin setup of Householder */
+	    q=a[k+1][k-1];                    /* vector. */
+	    r=0.0;
+	    if (k != (nn-1)) r=a[k+2][k-1];
+	    if ((x=fabs (p)+fabs (q)+fabs (r)) != 0.0) {
+	      p /= x;                     /* Scale to prevent overflow or */
+	      q /= x;                     /* underflow. */
+	      r /= x;
+	    }
+	  }
+	  if ((s=SIGN (sqrt (p*p+q*q+r*r),p)) != 0.0) {
+	    if (k == m) {
+	      if (l != m)
+		a[k][k-1] = -a[k][k-1];
+	    } else
+	      a[k][k-1] = -s*x;
+	    p += s;                           /* Equations (11.6.24). */
+	    x=p/s;
+	    y=q/s;
+	    z=r/s;
+	    q /= p;
+	    r /= p;
+	    for (j=k;j<=nn;j++) {             /* Row modification. */
+	      p=a[k][j]+q*a[k+1][j];
+	      if (k != (nn-1)) {
+		p += r*a[k+2][j];
+		a[k+2][j] -= p*z;
+	      }
+	      a[k+1][j] -= p*y;
+	      a[k][j] -= p*x;
+	    }
+	    mmin = nn<k+3 ? nn : k+3;
+	    for (i=l;i<=mmin;i++) {           /* Column modification. */
+	      p=x*a[i][k]+y*a[i][k+1];
+	      if (k != (nn-1)) {
+		p += z*a[i][k+2];
+		a[i][k+2] -= p*r;
+	      }a[i][k+1] -= p*q;
+	      a[i][k] -= p;
+	    }
+	  }
+	}
+      }
+    }
+    } while (l < nn-1);
+  }
+}
+
+#define RADIX 2.0
+static void
+balanc (double **a, int n)
+     /* Given a matrix a[1..n][1..n], this routine replaces it by a balanced matrix with identical
+	eigenvalues. A symmetric matrix is already balanced and is unaffected by this procedure. The
+	parameter RADIX should be the machine's floating-point radix. */
+{
+  int last,j,i;
+  double s,r,g,f,c,sqrdx;
+  
+  sqrdx=RADIX*RADIX;
+  last=0;
+  while (last == 0) {
+    last=1;
+    for (i=1;i<=n;i++) {        /* Calculate row and column norms. */
+      r=c=0.0;
+      for (j=1;j<=n;j++)
+	if (j != i) {
+	  c += fabs (a[j][i]);
+	  r += fabs (a[i][j]);
+	}
+      if (c && r) {     /*  If both are nonzero, */
+	g=r/RADIX;
+	f=1.0;
+	s=c+r;
+	while (c<g) {   /* find the integer power of the machine radix that */
+	  f *= RADIX;   /*  comes closest to balancing the matrix. */
+	  c *= sqrdx;
+	}
+	g=r*RADIX;
+	while (c>g) {
+	  f /= RADIX;
+	  c /= sqrdx;
+	}
+	if ((c+r)/f < 0.95*s) {
+	  last=0;
+	  g=1.0/f;
+	  for (j=1;j<=n;j++)
+	    a[i][j] *= g;  /*  Apply similarity transformation */
+	  for (j=1;j<=n;j++) a[j][i] *= f;
+	}
+      }
+    }
+  }
+}
+
+#define MAX_DEGREE 50
+
+static void
+zrhqr (double a[], int m, double rtr[], double rti[])
+     /* Find all the roots of a polynomial with real coefficients, E(i=0..m) a(i)x^i, given the degree m
+	and the coefficients a[0..m]. The method is to construct an upper Hessenberg matrix whose
+	eigenvalues are the desired roots, and then use the routines balanc and hqr. The real and
+	imaginary parts of the roots are returned in rtr[1..m] and rti[1..m], respectively. */
+{
+  int j,k;
+  double **hess,xr,xi;
+  
+  hess=matrix (1,MAX_DEGREE,1,MAX_DEGREE);
+  if (m > MAX_DEGREE || a[m] == 0.0 || /* TIMJ: */ fabs (a[m]) < 1e-15 )
+    nrerror ("bad args in zrhqr");
+  for (k=1;k<=m;k++)	            /* Construct the matrix. */
+    {
+      hess[1][k] = -a[m-k]/a[m];
+      for (j=2;j<=m;j++)
+	hess[j][k]=0.0;
+      if (k != m)
+	hess[k+1][k]=1.0;
+    }
+  balanc (hess,m);                  /* Find its eigenvalues. */
+  hqr (hess,m,rtr,rti);
+  if (0)		/* TIMJ: don't need sorting */
+    for (j=2;j<=m;j++)
+      {				    /* Sort roots by their real parts by straight insertion. */
+	xr=rtr[j];
+	xi=rti[j];
+	for (k=j-1;k>=1;k--)
+	  {
+	    if (rtr[k] <= xr)
+	      break;
+	    rtr[k+1]=rtr[k];
+	    rti[k+1]=rti[k];
+	  }
+	rtr[k+1]=xr;
+	rti[k+1]=xi;
+      }
+  free_matrix (hess,1,MAX_DEGREE,1,MAX_DEGREE);
+}
+
+
+#define EPSS 2.0e-16	/* TIMJ, was(float): 1.0e-7 */
+#define MR 8
+#define MT 100		/* TIMJ: was: 10 */
+#define MAXIT (MT*MR)
+/* Here EPSS is the estimated fractional roundoff error. We try to break (rare) limit cycles with
+   MR different fractional values, once every MT steps, for MAXIT total allowed iterations. */
+
+static void
+laguer (GslComplex a[], int m, GslComplex *x, int *its)
+     /* Given the degree m and the m+1 complex coefficients a[0..m] of the polynomial         mi=0 a[i]xi,
+	and given a complex value x, this routine improves x by Laguerre's method until it converges,
+	within the achievable roundoff limit, to a root of the given polynomial. The number of iterations
+	taken is returned as its. */
+{
+  int iter,j;
+  double abx,abp,abm,err;
+  GslComplex dx,x1,b,d,f,g,h,sq,gp,gm,g2;
+  static double frac[MR+1] = {0.0,0.5,0.25,0.75,0.13,0.38,0.62,0.88,1.0};
+  /* Fractions used to break a limit cycle. */
+  
+  for (iter=1;iter<=MAXIT;iter++)
+    {        /* Loop over iterations up to allowed maximum. */
+      *its=iter;
+      b=a[m];
+      err=gsl_complex_abs (b);
+      d=f=gsl_complex (0.0,0.0);
+      abx=gsl_complex_abs (*x);
+      for (j=m-1;j>=0;j--)
+	{            /* Efficient computation of the polynomial and */
+	  f=gsl_complex_add (gsl_complex_mul (*x,f),d);         /* its first two derivatives. */
+	  d=gsl_complex_add (gsl_complex_mul (*x,d),b);
+	  b=gsl_complex_add (gsl_complex_mul (*x,b),a[j]);
+	  err=gsl_complex_abs (b)+abx*err;
+	}
+      err *= EPSS;
+      /* Estimate of roundoff error in evaluating polynomial. */
+      if (gsl_complex_abs (b) <= err)
+	return;               /* We are on the root. */
+      g=gsl_complex_div (d,b);                              /* The generic case: use Laguerre's formula. */
+      g2=gsl_complex_mul (g,g);
+      h=gsl_complex_sub (g2,gsl_complex_rmul (2.0,gsl_complex_div (f,b)));
+      sq=gsl_complex_sqrt (gsl_complex_rmul ((double) (m-1),gsl_complex_sub (gsl_complex_rmul ((double) m,h),g2)));
+      gp=gsl_complex_add (g,sq);
+      gm=gsl_complex_sub (g,sq);
+      abp=gsl_complex_abs (gp);
+      abm=gsl_complex_abs (gm);
+      if (abp < abm)
+	gp=gm;
+      dx=((DMAX (abp,abm) > 0.0 ? gsl_complex_div (gsl_complex ((double) m,0.0),gp)
+	   : gsl_complex_rmul (1+abx,gsl_complex (cos ((double)iter),sin ((double)iter)))));
+      x1=gsl_complex_sub (*x,dx);
+      if (x->re == x1.re && x->im == x1.im)
+	return;                 /* Converged. */
+      if (iter % MT) *x=x1;
+      else *x=gsl_complex_sub (*x,gsl_complex_rmul (frac[iter/MT],dx));
+      /* Every so often we take a fractional step, to break any limit cycle (itself a rare occurrence). */
+    }
+  nrerror ("too many iterations in laguer");
+  /* Very unusual - can occur only for complex roots. Try a different starting guess for the root. */
+}
+
+/* Here is a driver routine that calls laguer in succession for each root, performs
+   the deflation, optionally polishes the roots by the same Laguerre method - if you
+   are not going to polish in some other way - and finally sorts the roots by their real
+   parts. (We will use this routine in Chapter 13.) */
+
+#define EPS	4.0e-15		/* TIMJ, was(float): 2.0e-6 */
+#define MAXM 100
+/* A small number, and maximum anticipated value of m. */
+
+static void
+zroots (GslComplex a[], int m, GslComplex roots[], int polish)
+     /* Given the degree m and the m+1 complex coefficients a[0..m] of the polynomial mi=0 a (i)xi,
+	this routine successively calls laguer and finds all m complex roots in roots[1..m]. The
+	boolean variable polish should be input as true (1) if polishing (also by Laguerre's method)
+	is desired, false (0) if the roots will be subsequently polished by other means. */
+{
+  int i,its,j,jj;
+  GslComplex x,b,c,ad[MAXM];
+  
+  for (j=0;j<=m;j++) ad[j]=a[j];              /* Copy of coefficients for successive deflation. */
+  for (j=m;j>=1;j--)                          /* Loop over each root to be found. */
+    {
+      x=gsl_complex (0.0,0.0);                  /* Start at zero to favor convergence to small- */
+      laguer (ad,j,&x,&its);                     /* est remaining root, and find the root. */
+      if (fabs (x.im) <= 2.0*EPS*fabs (x.re))
+	x.im=0.0;
+      roots[j]=x;
+      b=ad[j];                                  /* Forward deflation. */
+      for (jj=j-1;jj>=0;jj--)
+	{
+	  c=ad[jj];
+	  ad[jj]=b;
+	  b=gsl_complex_add (gsl_complex_mul (x,b),c);
+	}
+    }
+  if (polish)
+    for (j=1;j<=m;j++)                        /* Polish the roots using the undeflated coeffi- */
+      laguer (a,m,&roots[j],&its);            /* cients. */
+  for (j=2;j<=m;j++)                          /* Sort roots by their real parts by straight insertion */
+    {
+      x=roots[j];
+      for (i=j-1;i>=1;i--) {
+	if (roots[i].re <= x.re)
+	  break;
+	roots[i+1]=roots[i];
+      }
+      roots[i+1]=x;
+    }
+}
+
+#define ITMAX 20	/* At most ITMAX iterations. */
+#define TINY 2.0-15	/* TIMJ, was (float): 1.0e-6 */
+
+static void
+qroot (double p[], int n, double *b, double *c, double eps)
+     /* Given n+1 coefficients p[0..n] of a polynomial of degree n, and trial values for the coefficients
+	of a quadratic factor x*x+b*x+c, improve the solution until the coefficients b,c change by less
+	than eps. The routine poldiv §5.3 is used. */
+{
+  int iter;
+  double sc,sb,s,rc,rb,r,dv,delc,delb;
+  double *q,*qq,*rem;
+  double d[3];
+  
+  q=vector (0,n);
+  qq=vector (0,n);
+  rem=vector (0,n);
+  d[2]=1.0;
+  for (iter=1;iter<=ITMAX;iter++)
+    {
+      d[1]=(*b);
+      d[0]=(*c);
+      poldiv (p,n,d,2,q,rem);
+      s=rem[0];                                        /* First division r,s. */
+      r=rem[1];
+      poldiv (q,(n-1),d,2,qq,rem);
+      sb = -(*c)*(rc = -rem[1]);                       /* Second division partial r,s with respect to */
+      rb = -(*b)*rc+(sc = -rem[0]);                    /* c. */
+      dv=1.0/(sb*rc-sc*rb);                            /* Solve 2x2 equation. */
+      delb=(r*sc-s*rc)*dv;
+      delc=(-r*sb+s*rb)*dv;
+      *b += (delb=(r*sc-s*rc)*dv);
+      *c += (delc=(-r*sb+s*rb)*dv);
+      if ((fabs (delb) <= eps*fabs (*b) || fabs (*b) < TINY)
+	  && (fabs (delc) <= eps*fabs (*c) || fabs (*c) < TINY))
+	{
+	  free_vector (rem,0,n);                      /* Coefficients converged. */
+	  free_vector (qq,0,n);
+	  free_vector (q,0,n);
+	  return;
+	}
+    }
+  nrerror ("Too many iterations in routine qroot");
+}
+
+#define SNCNDN_CA 0.0003                      /* The accuracy is the square of SNCNDN_CA. */
+static void
+sncndn (double uu, double emmc, double *sn_p, double *cn_p, double *dn_p)
+     /* Returns the Jacobian elliptic functions sn(u, kc), cn(u, kc), and dn(u, kc). Here uu = u, while
+	emmc = k2c. */
+{
+  double a,b,c,d,emc,u,sn,cn,dn;
+  double em[14],en[14];
+  int i,ii,l,bo;
+  d=0; /* TIMJ: shutup compiler */
+  
+  emc=emmc;
+  u=uu;
+  if (emc) {
+    bo=(emc < 0.0);
+    if (bo) {
+      d=1.0-emc;
+      emc /= -1.0/d;
+      u *= (d=sqrt(d));
+    }a=1.0;
+    dn=1.0;
+    for (i=1;i<=13;i++) {
+      l=i;
+      em[i]=a;
+      en[i]=(emc=sqrt(emc));
+      c=0.5*(a+emc);
+      if (fabs(a-emc) <= SNCNDN_CA*a) break;
+      emc *= a;
+      a=c;
+    }u *= c;
+    sn=sin(u);
+    cn=cos(u);
+    if (sn) {
+      a=cn/sn;
+      c *= a;
+      for (ii=l;ii>=1;ii--) {
+	b=em[ii];
+	a *= c;
+	c *= dn;
+	dn=(en[ii]+a)/(b+a);
+	a=c/b;
+      }a=1.0/sqrt(c*c+1.0);
+      sn=(sn >= 0.0 ? a : -a);
+      cn=c*sn;
+    }if (bo) {
+      a=dn;
+      dn=cn;
+      cn=a;
+      sn /= d;
+    }
+  } else {
+    cn=1.0/cosh(u);
+    dn=cn;
+    sn=tanh(u);
+  }
+  if (sn_p)
+    *sn_p = sn;
+  if (cn_p)
+    *cn_p = cn;
+  if (dn_p)
+    *dn_p = dn;
+}
+
+static void
+sncndnC (GslComplex uu, GslComplex emmc, GslComplex *sn_p, GslComplex *cn_p, GslComplex *dn_p)
+{
+  GslComplex a,b,c,d,emc,u,sn,cn,dn;
+  GslComplex em[14],en[14];
+  int i,ii,l,bo;
+  
+  emc=emmc;
+  u=uu;
+  if (emc.re || emc.im) /* gsl_complex_abs (emc)) */
+    {
+      /* bo=gsl_complex_abs (emc) < 0.0; */
+      bo=emc.re < 0.0;
+      if (bo) {
+	d=gsl_complex_sub (ONE, emc);
+	emc = gsl_complex_div (emc, gsl_complex_div (gsl_complex (-1.0, 0), d));
+	d = gsl_complex_sqrt (d);
+	u = gsl_complex_mul (u, d);
+      }
+      a=ONE; dn=ONE;
+      for (i=1;i<=13;i++) {
+	l=i;
+	em[i]=a;
+	emc = gsl_complex_sqrt (emc);
+	en[i]=emc;
+	c = gsl_complex_mul (gsl_complex (0.5, 0), gsl_complex_add (a, emc));
+	if (gsl_complex_abs (gsl_complex_sub (a, emc)) <=
+	    gsl_complex_abs (gsl_complex_mul (gsl_complex (SNCNDN_CA, 0), a)))
+	  break;
+	emc = gsl_complex_mul (emc, a);
+	a=c;
+      }
+      u = gsl_complex_mul (u, c);
+      sn = gsl_complex_sin (u);
+      cn = gsl_complex_cos (u);
+      if (sn.re) /* gsl_complex_abs (sn)) */
+	{
+	  a= gsl_complex_div (cn, sn);
+	  c = gsl_complex_mul (c, a);
+	  for (ii=l;ii>=1;ii--) {
+	    b = em[ii];
+	    a = gsl_complex_mul (a, c);
+	    c = gsl_complex_mul (c, dn);
+	    dn = gsl_complex_div (gsl_complex_add (en[ii], a), gsl_complex_add (b, a));
+	    a = gsl_complex_div (c, b);
+	  }
+	  a = gsl_complex_div (ONE, gsl_complex_sqrt (gsl_complex_add (ONE, gsl_complex_mul (c, c))));
+	  if (sn.re >= 0.0) /* gsl_complex_arg (sn) >= 0.0) */
+	    sn = a;
+	  else
+	    {
+	      sn.re = -a.re;
+	      sn.im = a.im;
+	    }
+	  cn = gsl_complex_mul (c, sn);
+	}
+      if (bo) {
+	a=dn;
+	dn=cn;
+	cn=a;
+	sn = gsl_complex_div (sn, d);
+      }
+    } else {
+      cn=gsl_complex_div (ONE, gsl_complex_cosh (u));
+      dn=cn;
+      sn=gsl_complex_tanh (u);
+    }
+  if (sn_p)
+    *sn_p = sn;
+  if (cn_p)
+    *cn_p = cn;
+  if (dn_p)
+    *dn_p = dn;
+}
+
+#define RF_ERRTOL	0.0025		/* TIMJ, was(float): 0.08 */
+#define RF_TINY		2.2e-307	/* TIMJ, was(float): 1.5e-38 */
+#define RF_BIG		1.5e+307	/* TIMJ, was(float):  3.0e37 */
+#define RF_THIRD	(1.0/3.0)
+#define RF_C1		(1.0/24.0)
+#define RF_C2		0.1
+#define RF_C3		(3.0/44.0)
+#define RF_C4		(1.0/14.0)
+
+static double
+rf (double x, double y, double z)
+     /* Computes Carlson's elliptic integral of the first kind, RF (x, y, z). x, y, and z must be nonneg-
+	ative, and at most one can be zero. RF_TINY must be at least 5 times the machine underflow limit,
+	RF_BIG at most one fifth the machine overflow limit. */
+{
+  double alamb,ave,delx,dely,delz,e2,e3,sqrtx,sqrty,sqrtz,xt,yt,zt;
+  
+  if (1 /* TIMJ: add verbose checks */)
+    {
+      if (DMIN (DMIN (x, y), z) < 0.0)
+	nrerror ("rf: x,y,z have to be positive");
+      if (DMIN (DMIN (x + y, x + z), y + z) < RF_TINY)
+	nrerror ("rf: only one of x,y,z may be 0");
+      if (DMAX (DMAX (x, y), z) > RF_BIG)
+	nrerror ("rf: at least one of x,y,z is too big");
+    }
+  if (DMIN(DMIN(x,y),z) < 0.0 || DMIN(DMIN(x+y,x+z),y+z) < RF_TINY ||
+      DMAX(DMAX(x,y),z) > RF_BIG)
+    nrerror("invalid arguments in rf");
+  xt=x;
+  yt=y;
+  zt=z;
+  do {
+    sqrtx=sqrt(xt);
+    sqrty=sqrt(yt);
+    sqrtz=sqrt(zt);
+    alamb=sqrtx*(sqrty+sqrtz)+sqrty*sqrtz;
+    xt=0.25*(xt+alamb);
+    yt=0.25*(yt+alamb);
+    zt=0.25*(zt+alamb);
+    ave=RF_THIRD*(xt+yt+zt);
+    delx=(ave-xt)/ave;
+    dely=(ave-yt)/ave;
+    delz=(ave-zt)/ave;
+  } while (DMAX(DMAX(fabs(delx),fabs(dely)),fabs(delz)) > RF_ERRTOL);
+  e2=delx*dely-delz*delz;
+  e3=delx*dely*delz;
+  return (1.0+(RF_C1*e2-RF_C2-RF_C3*e3)*e2+RF_C4*e3)/sqrt(ave);
+}
+
+static GslComplex
+rfC (GslComplex x, GslComplex y, GslComplex z)
+{
+  GslComplex alamb,ave,delx,dely,delz,e2,e3,sqrtx,sqrty,sqrtz,xt,yt,zt;
+  GslComplex RFC_C1 = {1.0/24.0, 0}, RFC_C2 = {0.1, 0}, RFC_C3 = {3.0/44.0, 0}, RFC_C4 = {1.0/14.0, 0};
+  
+  if (DMIN (DMIN (gsl_complex_abs (x), gsl_complex_abs (y)), gsl_complex_abs (z)) < 0.0)
+    nrerror ("rf: x,y,z have to be positive");
+  if (DMIN (DMIN (gsl_complex_abs (x) + gsl_complex_abs (y), gsl_complex_abs (x) + gsl_complex_abs (z)),
+	    gsl_complex_abs (y) + gsl_complex_abs (z)) < RF_TINY)
+    nrerror ("rf: only one of x,y,z may be 0");
+  if (DMAX (DMAX (gsl_complex_abs (x), gsl_complex_abs (y)), gsl_complex_abs (z)) > RF_BIG)
+    nrerror ("rf: at least one of x,y,z is too big");
+  xt=x;
+  yt=y;
+  zt=z;
+  do {
+    sqrtx = gsl_complex_sqrt (xt);
+    sqrty = gsl_complex_sqrt (yt);
+    sqrtz = gsl_complex_sqrt (zt);
+    alamb = gsl_complex_add (gsl_complex_mul (sqrtx, gsl_complex_add (sqrty, sqrtz)), gsl_complex_mul (sqrty, sqrtz));
+    xt =    gsl_complex_mul (gsl_complex (0.25, 0), gsl_complex_add (xt, alamb));
+    yt =    gsl_complex_mul (gsl_complex (0.25, 0), gsl_complex_add (yt, alamb));
+    zt =    gsl_complex_mul (gsl_complex (0.25, 0), gsl_complex_add (zt, alamb));
+    ave =   gsl_complex_mul (gsl_complex (RF_THIRD, 0), gsl_complex_add3 (xt, yt, zt));
+    delx =  gsl_complex_div (gsl_complex_sub (ave, xt), ave);
+    dely =  gsl_complex_div (gsl_complex_sub (ave, yt), ave);
+    delz =  gsl_complex_div (gsl_complex_sub (ave, zt), ave);
+    /* } while (DMAX (DMAX (fabs (delx.re), fabs (dely.re)), fabs (delz.re)) > RF_ERRTOL); */
+  } while (DMAX (DMAX (gsl_complex_abs (delx), gsl_complex_abs (dely)), gsl_complex_abs (delz)) > RF_ERRTOL);
+  e2 = gsl_complex_sub (gsl_complex_mul (delx, dely), gsl_complex_mul (delz, delz));
+  e3 = gsl_complex_mul3 (delx, dely, delz);
+  return gsl_complex_div (gsl_complex_add3 (gsl_complex (1.0, 0),
+					    gsl_complex_mul (e2,
+							     gsl_complex_sub3 (gsl_complex_mul (RFC_C1, e2),
+									       RFC_C2,
+									       gsl_complex_mul (RFC_C3, e3))),
+					    gsl_complex_mul (RFC_C4, e3)),
+			  gsl_complex_sqrt (ave));
+}
+
+
+static double
+ellf (double phi, double ak)
+     /* Legendre elliptic integral of the 1st kind F(phi, k), evaluated using Carlson's function RF.
+	The argument ranges are 0 <= phi <= pi/2, 0 <=  k*sin(phi) <= 1. */
+{
+  double s=sin(phi);
+  return s*rf(DSQR(cos(phi)),(1.0-s*ak)*(1.0+s*ak),1.0);
+}
diff --git a/flow/gsl/gslmath.h b/flow/gsl/gslmath.h
new file mode 100644
index 0000000..b690a54
--- /dev/null
+++ b/flow/gsl/gslmath.h
@@ -0,0 +1,518 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Stefan Westerfeld and Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_MATH_H__
+#define __GSL_MATH_H__
+
+#include <gsl/gslieee754.h>
+#include <gsl/gsldefs.h>
+#include <math.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- constants --- */
+#define GSL_PI                  (3.1415926535897932384626433832795029 /* pi */)
+#define GSL_PI_DIV_2            (1.5707963267948966192313216916397514 /* pi/2 */)
+#define GSL_PI_DIV_4            (0.7853981633974483096156608458198757 /* pi/4 */)
+#define GSL_1_DIV_PI            (0.3183098861837906715377675267450287 /* 1/pi */)
+#define GSL_2_DIV_PI            (0.6366197723675813430755350534900574 /* 2/pi */)
+#define GSL_2_DIV_SQRT_PI       (1.1283791670955125738961589031215452 /* 2/sqrt(pi) */)
+#define GSL_SQRT2               (1.4142135623730950488016887242096981 /* sqrt(2) */)
+#define GSL_1_DIV_SQRT2         (0.7071067811865475244008443621048490 /* 1/sqrt(2) */)
+#define GSL_E                   (2.7182818284590452353602874713526625 /* e */)
+#define GSL_LOG2E               (1.4426950408889634073599246810018922 /* log_2(e) */)
+#define GSL_LOG10E              (0.4342944819032518276511289189166051 /* log_10(e) */)
+#define GSL_LN2                 (0.6931471805599453094172321214581766 /* ln(2) */)
+#define GSL_LN10                (2.3025850929940456840179914546843642 /* ln(10) */)
+#define	GSL_2_POW_1_DIV_12	(1.0594630943592952645618252949463417 /* 2^(1/12) */)
+#define	GSL_2_POW_1_DIV_72	(1.0096735332285108621925214011186051 /* 2^(1/72) */)
+#define	GSL_LN_2_POW_1_DIV_12	(0.0577622650466621091181026767881814 /* ln(2^(1/12)) */)
+#define	GSL_LN_2_POW_1_DIV_72	(0.0096270441744436848530171127980302 /* ln(2^(1/72)) */)
+#define GSL_LOG2_10             (3.3219280948873623478703194294893902 /* log_2(10) */)
+#define GSL_LOG2POW20_10        (0.1660964047443681173935159714744695 /* log_2(10)/20 */)
+
+
+/* --- structures --- */
+struct _GslComplex
+{
+  double re;
+  double im;
+};
+
+
+/* --- float/double signbit extraction --- */
+#ifdef signbit
+#  define       gsl_float_sign(dblflt)  (signbit (dblflt))
+#else
+#  define       gsl_float_sign(dblflt)  ((dblflt) < -0.0)       /* good enough for us */
+#endif
+
+
+/* --- complex numbers --- */
+static inline GslComplex gsl_complex		(double		re,
+						 double		im);
+static inline GslComplex gsl_complex_polar	(double		abs,
+						 double		arg);
+static inline GslComplex gsl_complex_add	(GslComplex	c1,
+						 GslComplex	c2);
+static inline GslComplex gsl_complex_add3	(GslComplex	c1,
+						 GslComplex	c2,
+						 GslComplex	c3);
+static inline GslComplex gsl_complex_sub	(GslComplex	c1,
+						 GslComplex	c2);
+static inline GslComplex gsl_complex_sub3	(GslComplex	c1,
+						 GslComplex	c2,
+						 GslComplex	c3);
+static inline GslComplex gsl_complex_scale	(GslComplex	c1,
+						 double    	scale);
+static inline GslComplex gsl_complex_mul	(GslComplex	c1,
+						 GslComplex	c2);
+static inline GslComplex gsl_complex_mul3	(GslComplex	c1,
+						 GslComplex	c2,
+						 GslComplex	c3);
+static inline GslComplex gsl_complex_div	(GslComplex	a,
+						 GslComplex	b);
+static inline GslComplex gsl_complex_reciprocal	(GslComplex	c);
+static inline GslComplex gsl_complex_sqrt	(GslComplex	z);
+static inline GslComplex gsl_complex_conj	(GslComplex	c); /* {re, -im} */
+static inline GslComplex gsl_complex_id		(GslComplex	c);
+static inline GslComplex gsl_complex_inv	(GslComplex	c); /* {-re, -im} */
+static inline double	 gsl_complex_abs	(GslComplex	c);
+static inline double	 gsl_complex_arg	(GslComplex	c);
+static inline GslComplex gsl_complex_sin	(GslComplex     c);
+static inline GslComplex gsl_complex_cos	(GslComplex     c);
+static inline GslComplex gsl_complex_tan	(GslComplex     c);
+static inline GslComplex gsl_complex_sinh	(GslComplex     c);
+static inline GslComplex gsl_complex_cosh	(GslComplex     c);
+static inline GslComplex gsl_complex_tanh	(GslComplex     c);
+char*			 gsl_complex_str	(GslComplex	c);
+char*			 gsl_complex_list	(unsigned int	n_points,
+						 GslComplex    *points,
+						 const char    *indent);
+void			 gsl_complex_gnuplot	(const char    *file_name,
+						 unsigned int   n_points,
+						 GslComplex    *points);
+
+
+/* --- polynomials --- */
+/* example, degree=2: 5+2x+7x^2 => a[0..degree] = { 5, 2, 7 } */
+static inline void     gsl_poly_add		(unsigned int	degree,
+						 double	       *a, /* a[0..degree] */
+						 double	       *b);
+static inline void     gsl_poly_sub		(unsigned int	order,
+						 double	       *a, /* [0..degree] */
+						 double	       *b);
+static inline void     gsl_poly_mul		(double	       *p,  /* out:[0..aorder+border] */
+                                                 unsigned int   aorder,
+						 const double  *a,  /* in:[0..aorder] */
+						 unsigned int   border,
+						 const double  *b); /* in:[0..border] */
+static inline void     gsl_poly_scale		(unsigned int	order,
+						 double	       *a, /* [0..degree] */
+						 double		scale);
+static inline void     gsl_poly_xscale		(unsigned int	order,
+						 double	       *a, /* [0..degree] */
+						 double		xscale);
+static inline double   gsl_poly_eval		(unsigned int	degree,
+						 double	       *a, /* [0..degree] */
+						 double		x);
+void		       gsl_poly_complex_roots	(unsigned int	poly_degree,
+						 double	       *a, /* [0..degree] (degree+1 elements) */
+						 GslComplex    *roots); /* [degree] */
+void		       gsl_poly_from_re_roots	(unsigned int	poly_degree,
+						 double	       *a, /* [0..degree] */
+						 GslComplex    *roots);
+void		       gsl_cpoly_from_roots	(unsigned int	poly_degree,
+						 GslComplex    *c, /* [0..degree] */
+						 GslComplex    *roots);
+static inline void     gsl_cpoly_mul_monomial	(unsigned int	degree, /* _new_ degree */
+						 GslComplex    *c, /* in:[0..degree-1] out:[0..degree] */
+						 GslComplex	root); /* c(x) *= (x^1 - root) */
+static inline void     gsl_cpoly_mul_reciprocal	(unsigned int	degree, /* _new_ degree */
+						 GslComplex    *c, /* in:[0..degree-1] out:[0..degree] */
+						 GslComplex	root); /* c(x) *= (1 - root * x^-1) */
+static inline void     gsl_cpoly_mul		(GslComplex    *p,  /* out:[0..aorder+border] */
+						 unsigned int   aorder,
+						 GslComplex    *a,  /* in:[0..aorder] */
+						 unsigned int   border,
+						 GslComplex    *b); /* in:[0..border] */
+
+char*		       gsl_poly_str		(unsigned int	degree,
+						 double	       *a,
+						 const char    *var);
+char*		       gsl_poly_str1		(unsigned int	degree,
+						 double	       *a,
+						 const char    *var);
+
+
+/* --- transformations --- */
+double			 gsl_temp_freq		(double		kammer_freq,
+						 int		halftone_delta);
+
+
+/* --- miscellaneous --- */
+double			gsl_bit_depth_epsilon	(guint		n_bits); /* 1..32 */
+
+
+/* --- ellipses --- */
+double			 gsl_ellip_rf		(double 	x,
+						 double		y,
+						 double		z);
+double			 gsl_ellip_F		(double		phi,
+						 double		ak);
+double			 gsl_ellip_sn		(double 	u,
+						 double		emmc);
+double			 gsl_ellip_asn		(double		y,
+						 double		emmc);
+GslComplex		 gsl_complex_ellip_asn	(GslComplex	y,
+						 GslComplex	emmc);
+GslComplex		 gsl_complex_ellip_sn	(GslComplex 	u,
+						 GslComplex	emmc);
+
+
+/* --- implementations --- */
+static inline GslComplex
+gsl_complex (double re,
+	     double im)
+{
+  GslComplex r;
+  r.re = re;
+  r.im = im;
+  return r;
+}
+static inline GslComplex
+gsl_complex_polar (double abs,
+		   double arg)
+{
+  return gsl_complex (abs * cos (arg), abs * sin (arg));
+}
+static inline GslComplex
+gsl_complex_add	(GslComplex c1,
+		 GslComplex c2)
+{
+  return gsl_complex (c1.re + c2.re, c1.im + c2.im);
+}
+static inline GslComplex
+gsl_complex_add3 (GslComplex c1,
+		  GslComplex c2,
+		  GslComplex c3)
+{
+  return gsl_complex (c1.re + c2.re + c3.re, c1.im + c2.im + c3.im);
+}
+static inline GslComplex
+gsl_complex_sub	(GslComplex c1,
+		 GslComplex c2)
+{
+  return gsl_complex (c1.re - c2.re, c1.im - c2.im);
+}
+static inline GslComplex
+gsl_complex_sub3 (GslComplex c1,
+		  GslComplex c2,
+		  GslComplex c3)
+{
+  return gsl_complex (c1.re - c2.re - c3.re, c1.im - c2.im - c3.im);
+}
+static inline GslComplex
+gsl_complex_scale (GslComplex c1,
+		   double     scale)
+{
+  return gsl_complex (c1.re * scale, c1.im * scale);
+}
+static inline GslComplex
+gsl_complex_mul (GslComplex c1,
+		 GslComplex c2)
+{
+  return gsl_complex (c1.re * c2.re - c1.im * c2.im, c1.re * c2.im + c1.im * c2.re);
+}
+static inline GslComplex
+gsl_complex_mul3 (GslComplex c1,
+		  GslComplex c2,
+		  GslComplex c3)
+{
+  double aec = c1.re * c2.re * c3.re;
+  double bde = c1.im * c2.im * c3.re;
+  double adf = c1.re * c2.im * c3.im;
+  double bcf = c1.im * c2.re * c3.im;
+  double ade = c1.re * c2.im * c3.re;
+  double bce = c1.im * c2.re * c3.re;
+  double acf = c1.re * c2.re * c3.im;
+  double bdf = c1.im * c2.im * c3.im;
+  
+  return gsl_complex (aec - bde - adf - bcf, ade + bce + acf - bdf);
+}
+static inline GslComplex
+gsl_complex_div	(GslComplex a,
+		 GslComplex b)
+{
+  GslComplex c;
+  if (fabs (b.re) >= fabs (b.im))
+    {
+      double r = b.im / b.re, den = b.re + r * b.im;
+      c.re = (a.re + r * a.im) / den;
+      c.im = (a.im - r * a.re) / den;
+    }
+  else
+    {
+      double r = b.re / b.im, den = b.im + r * b.re;
+      c.re = (a.re * r + a.im) / den;
+      c.im = (a.im * r - a.re) / den;
+    }
+  return c;
+}
+static inline GslComplex
+gsl_complex_reciprocal (GslComplex c)
+{
+  if (fabs (c.re) >= fabs (c.im))
+    {
+      double r = c.im / c.re, den = c.re + r * c.im;
+      c.re = 1. / den;
+      c.im = - r / den;
+    }
+  else
+    {
+      double r = c.re / c.im, den = c.im + r * c.re;
+      c.re = r / den;
+      c.im = - 1. / den;
+    }
+  return c;
+}
+static inline GslComplex
+gsl_complex_sqrt (GslComplex z)
+{
+  if (z.re == 0.0 && z.im == 0.0)
+    return z;
+  else
+    {
+      GslComplex c;
+      double w, x = fabs (z.re), y = fabs (z.im);
+      if (x >= y)
+	{
+	  double r = y / x;
+	  w = sqrt (x) * sqrt (0.5 * (1.0 + sqrt (1.0 + r * r)));
+	}
+      else
+	{
+	  double r = x / y;
+	  w = sqrt (y) * sqrt (0.5 * (r + sqrt (1.0 + r * r)));
+	}
+      if (z.re >= 0.0)
+	{
+	  c.re = w;
+	  c.im = z.im / (2.0 * w);
+	}
+      else
+	{
+	  c.im = z.im >= 0 ? w : -w;
+	  c.re = z.im / (2.0 * c.im);
+	}
+      return c;
+    }
+}
+static inline GslComplex
+gsl_complex_conj (GslComplex c)
+{
+  return gsl_complex (c.re, -c.im);
+}
+static inline GslComplex
+gsl_complex_inv (GslComplex c)
+{
+  return gsl_complex (-c.re, -c.im);
+}
+static inline GslComplex
+gsl_complex_id (GslComplex c)
+{
+  return c;
+}
+static inline double
+gsl_complex_abs (GslComplex c)
+{
+  /* compute (a^2 + b^2)^(1/2) without destructive underflow or overflow */
+  double absa = fabs (c.re), absb = fabs (c.im);
+  return (absa > absb ?
+	  absb == 0.0 ? absa :
+	  absa * sqrt (1.0 + (absb / absa) * (absb / absa)) :
+	  absb == 0.0 ? 0.0 :
+	  absb * sqrt (1.0 + (absa / absb) * (absa / absb)));
+}
+static inline double
+gsl_complex_arg (GslComplex c)
+{
+  double a = atan2 (c.im, c.re);
+  return a;
+}
+static inline GslComplex
+gsl_complex_sin (GslComplex c)
+{
+  return gsl_complex (sin (c.re) * cosh (c.im), cos (c.re) * sinh (c.im));
+}
+static inline GslComplex
+gsl_complex_cos (GslComplex c)
+{
+  return gsl_complex (cos (c.re) * cosh (c.im), - sin (c.re) * sinh (c.im));
+}
+static inline GslComplex
+gsl_complex_tan (GslComplex c)
+{
+  return gsl_complex_div (gsl_complex (tan (c.re), tanh (c.im)),
+			  gsl_complex (1.0, -tan (c.re) * tanh (c.im)));
+}
+static inline GslComplex
+gsl_complex_sinh (GslComplex c)
+{
+  return gsl_complex (sinh (c.re) * cos (c.im), cosh (c.re) * sin (c.im));
+}
+static inline GslComplex
+gsl_complex_cosh (GslComplex c)
+{
+  return gsl_complex (cosh (c.re) * cos (c.im), sinh (c.re) * sin (c.im));
+}
+static inline GslComplex
+gsl_complex_tanh (GslComplex c)
+{
+  return gsl_complex_div (gsl_complex_sinh (c),
+			  gsl_complex_cosh (c));
+}
+static inline void
+gsl_poly_add (unsigned int degree,
+	      double      *a,
+	      double      *b)
+{
+  unsigned int i;
+  
+  for (i = 0; i <= degree; i++)
+    a[i] += b[i];
+}
+static inline void
+gsl_poly_sub (unsigned int degree,
+	      double      *a,
+	      double      *b)
+{
+  unsigned int i;
+  
+  for (i = 0; i <= degree; i++)
+    a[i] -= b[i];
+}
+static inline void
+gsl_poly_mul (double        *p,  /* out:[0..aorder+border] */
+	      unsigned int   aorder,
+	      const double  *a,  /* in:[0..aorder] */
+	      unsigned int   border,
+	      const double  *b)  /* in:[0..border] */
+{
+  unsigned int i;
+
+  for (i = aorder + border; i > 0; i--)
+    {
+      unsigned int j;
+      double t = 0;
+
+      for (j = i - MIN (border, i); j <= MIN (aorder, i); j++)
+	t += a[j] * b[i - j];
+      p[i] = t;
+    }
+  p[0] = a[0] * b[0];
+}
+static inline void
+gsl_cpoly_mul_monomial (unsigned int degree,
+			GslComplex  *c,
+			GslComplex   root)
+{
+  unsigned int j;
+  
+  c[degree] = c[degree - 1];
+  for (j = degree - 1; j >= 1; j--)
+    c[j] = gsl_complex_sub (c[j - 1], gsl_complex_mul (c[j], root));
+  c[0] = gsl_complex_mul (c[0], gsl_complex_inv (root));
+}
+static inline void
+gsl_cpoly_mul_reciprocal (unsigned int degree,
+			  GslComplex  *c,
+			  GslComplex   root)
+{
+  unsigned int j;
+  
+  c[degree] = gsl_complex_mul (c[degree - 1], gsl_complex_inv (root));
+  for (j = degree - 1; j >= 1; j--)
+    c[j] = gsl_complex_sub (c[j], gsl_complex_mul (c[j - 1], root));
+  /* c[0] = c[0]; */
+}
+static inline void
+gsl_cpoly_mul (GslComplex  *p,	/* [0..aorder+border] */
+	       unsigned int aorder,
+	       GslComplex  *a,
+	       unsigned int border,
+	       GslComplex  *b)
+{
+  unsigned int i;
+
+  for (i = aorder + border; i > 0; i--)
+    {
+      GslComplex t;
+      unsigned int j;
+
+      t = gsl_complex (0, 0);
+      for (j = i - MIN (i, border); j <= MIN (aorder, i); j++)
+	t = gsl_complex_add (t, gsl_complex_mul (a[j], b[i - j]));
+      p[i] = t;
+    }
+  p[0] = gsl_complex_mul (a[0], b[0]);
+}
+static inline void
+gsl_poly_scale (unsigned int degree,
+		double      *a,
+		double       scale)
+{
+  unsigned int i;
+  
+  for (i = 0; i <= degree; i++)
+    a[i] *= scale;
+}
+static inline void
+gsl_poly_xscale (unsigned int degree,
+		 double      *a,
+		 double       xscale)
+{
+  double scale = xscale;
+  unsigned int i;
+  
+  for (i = 1; i <= degree; i++)
+    {
+      a[i] *= scale;
+      scale *= xscale;
+    }
+}
+static inline double
+gsl_poly_eval (unsigned int degree,
+	       double	   *a,
+	       double	    x)
+{
+  double sum = a[degree];
+  
+  while (degree--)
+    sum = sum * x + a[degree];
+  return sum;
+}
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_MATH_H__ */	/* vim: set ts=8 sw=2 sts=2: */
diff --git a/flow/gsl/gslmathtest.c b/flow/gsl/gslmathtest.c
new file mode 100644
index 0000000..55130aa
--- /dev/null
+++ b/flow/gsl/gslmathtest.c
@@ -0,0 +1,334 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Stefan Westerfeld and Tim Janik
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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 <gsl/gslmath.h>
+#include <gsl/gslfilter.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define	PREC	"15"
+
+static void
+usage (char *s)
+{
+  printf ("usage: gslmathtest %s\n", s);
+  exit (1);
+}
+
+int
+main (int   argc,
+      char *argv[])
+{
+  gchar *arg;
+
+  if (argc < 2)
+    goto abort;
+
+  if (strcmp (argv[1], "rf") == 0)
+    {
+      double x, y, z;
+      if (argc != 5)
+	usage ("rf <x> <y> <z>");
+      x = atof (argv[2]);
+      y = atof (argv[3]);
+      z = atof (argv[4]);
+      
+      printf ("rf(%f, %f, %f) = %."PREC"f\n", x, y, z, gsl_ellip_rf (x, y, z));
+    }
+  else if (strcmp (argv[1], "F") == 0)
+    {
+      double phi, ak;
+      if (argc != 4)
+	usage ("F <phi> <ak>");
+      phi = atof (argv[2]);
+      ak = atof (argv[3]);
+      
+      printf ("F(%f, %f) = %."PREC"f\n", phi, ak, gsl_ellip_F (phi, ak));
+    }
+  else if (strcmp (argv[1], "sn") == 0)
+    {
+      double u, emmc;
+      if (argc != 4)
+	usage ("sn <u> <emmc>");
+      u = atof (argv[2]);
+      emmc = atof (argv[3]);
+      
+      printf ("sn(%f, %f) = %."PREC"f\n", u, emmc, gsl_ellip_sn (u, emmc));
+    }
+  else if (strcmp (argv[1], "snc") == 0)
+    {
+      GslComplex u, emmc;
+      if (argc != 6)
+	usage ("sn <u.re> <u.im> <emmc.re> <emmc.im>");
+      u.re = atof (argv[2]);
+      u.im = atof (argv[3]);
+      emmc.re = atof (argv[4]);
+      emmc.im = atof (argv[5]);
+      
+      printf ("snc(%s, %s) = %s\n",
+	      gsl_complex_str (u),
+	      gsl_complex_str (emmc),
+	      gsl_complex_str (gsl_complex_ellip_sn (u, emmc)));
+    }
+  else if (strcmp (argv[1], "sci_snc") == 0)
+    {
+      GslComplex u, k2;
+      if (argc != 6)
+	usage ("sci_sn <u.re> <u.im> <k2.re> <k2.im>");
+      u.re = atof (argv[2]);
+      u.im = atof (argv[3]);
+      k2.re = atof (argv[4]);
+      k2.im = atof (argv[5]);
+      
+      printf ("sci_snc(%s, %s) = %s\n",
+	      gsl_complex_str (u),
+	      gsl_complex_str (k2),
+	      gsl_complex_str (gsl_complex_ellip_sn (u, gsl_complex_sub (gsl_complex (1.0, 0), k2))));
+    }
+  else if (strcmp (argv[1], "asn") == 0)
+    {
+      double y, emmc;
+      if (argc != 4)
+	usage ("asn <y> <emmc>");
+      y = atof (argv[2]);
+      emmc = atof (argv[3]);
+      
+      printf ("asn(%f, %f) = %."PREC"f\n", y, emmc, gsl_ellip_asn (y, emmc));
+    }
+  else if (strcmp (argv[1], "asnc") == 0)
+    {
+      GslComplex y, emmc;
+      if (argc != 6)
+	usage ("asnc <y.re> <y.im> <emmc.re> <emmc.im>");
+      y.re = atof (argv[2]);
+      y.im = atof (argv[3]);
+      emmc.re = atof (argv[4]);
+      emmc.im = atof (argv[5]);
+      
+      printf ("asnc(%s, %s) = %s\n",
+	      gsl_complex_str (y), gsl_complex_str (emmc),
+	      gsl_complex_str (gsl_complex_ellip_asn (y, emmc)));
+      printf ("asn(%f, %f = %."PREC"f\n",
+	      y.re, emmc.re, gsl_ellip_asn (y.re, emmc.re));
+    }
+  else if (strcmp (argv[1], "sci_sn") == 0)
+    {
+      double u, k2;
+      if (argc != 4)
+	usage ("sci_sn <u> <k2>");
+      u = atof (argv[2]);
+      k2 = atof (argv[3]);
+      
+      printf ("sci_sn(%f, %f) = %."PREC"f\n", u, k2, gsl_ellip_sn (u, 1.0 - k2));
+    }
+  else if (strcmp (argv[1], "sci_asn") == 0)
+    {
+      double y, k2;
+      if (argc != 4)
+	usage ("sci_asn <y> <k2>");
+      y = atof (argv[2]);
+      k2 = atof (argv[3]);
+      
+      printf ("sci_asn(%f, %f) = %."PREC"f\n", y, k2, gsl_ellip_asn (y, 1.0 - k2));
+    }
+  else if (strcmp (argv[1], "sci_asnc") == 0)
+    {
+      GslComplex y, k2;
+      if (argc != 6)
+	usage ("sci_asnc <y.re> <y.im> <k2.re> <k2.im>");
+      y.re = atof (argv[2]);
+      y.im = atof (argv[3]);
+      k2.re = atof (argv[4]);
+      k2.im = atof (argv[5]);
+      
+      printf ("sci_asnc(%s, %s) = %s\n",
+	      gsl_complex_str (y), gsl_complex_str (k2),
+	      gsl_complex_str (gsl_complex_ellip_asn (y, gsl_complex_sub (gsl_complex (1.0, 0), k2))));
+      printf ("asn(%f, %f = %."PREC"f\n",
+	      y.re, k2.re, gsl_ellip_asn (y.re, 1.0 - k2.re));
+    }
+  else if (strcmp (argv[1], "sin") == 0)
+    {
+      GslComplex phi;
+      if (argc != 4)
+	usage ("sin <phi.re> <phi.im>");
+      phi.re = atof (argv[2]);
+      phi.im = atof (argv[3]);
+      
+      printf ("sin(%s) = %s\n",
+	      gsl_complex_str (phi),
+	      gsl_complex_str (gsl_complex_sin (phi)));
+    }
+  else if (strcmp (argv[1], "cos") == 0)
+    {
+      GslComplex phi;
+      if (argc != 4)
+	usage ("cos <phi.re> <phi.im>");
+      phi.re = atof (argv[2]);
+      phi.im = atof (argv[3]);
+      
+      printf ("cos(%s) = %s\n",
+	      gsl_complex_str (phi),
+	      gsl_complex_str (gsl_complex_cos (phi)));
+    }
+  else if (strcmp (argv[1], "tan") == 0)
+    {
+      GslComplex phi;
+      if (argc != 4)
+	usage ("tan <phi.re> <phi.im>");
+      phi.re = atof (argv[2]);
+      phi.im = atof (argv[3]);
+      
+      printf ("tan(%s) = %s\n",
+	      gsl_complex_str (phi),
+	      gsl_complex_str (gsl_complex_tan (phi)));
+    }
+  else if (strcmp (argv[1], "sinh") == 0)
+    {
+      GslComplex phi;
+      if (argc != 4)
+	usage ("sinh <phi.re> <phi.im>");
+      phi.re = atof (argv[2]);
+      phi.im = atof (argv[3]);
+      
+      printf ("sinh(%s) = %s\n",
+	      gsl_complex_str (phi),
+	      gsl_complex_str (gsl_complex_sinh (phi)));
+    }
+  else if (strcmp (argv[1], "cosh") == 0)
+    {
+      GslComplex phi;
+      if (argc != 4)
+	usage ("cosh <phi.re> <phi.im>");
+      phi.re = atof (argv[2]);
+      phi.im = atof (argv[3]);
+      
+      printf ("cosh(%s) = %s\n",
+	      gsl_complex_str (phi),
+	      gsl_complex_str (gsl_complex_cosh (phi)));
+    }
+  else if (strcmp (argv[1], "tanh") == 0)
+    {
+      GslComplex phi;
+      if (argc != 4)
+	usage ("tanh <phi.re> <phi.im>");
+      phi.re = atof (argv[2]);
+      phi.im = atof (argv[3]);
+      
+      printf ("tanh(%s) = %s\n",
+	      gsl_complex_str (phi),
+	      gsl_complex_str (gsl_complex_tanh (phi)));
+    }
+  else if (strcmp (argv[1], "t1") == 0)
+    {
+      guint order;
+      double f, e;
+      if (argc != 5)
+	usage ("t1 <order> <freq> <epsilon>");
+      order = atoi (argv[2]);
+      f = atof (argv[3]);
+      e = atof (argv[4]);
+      f *= GSL_PI / 2.;
+      e = gsl_trans_zepsilon2ss (e);
+      {
+	double a[order + 1], b[order + 1];
+	gsl_filter_tscheb1 (order, f, e, a, b);
+	g_print ("# Tschebyscheff Type1 order=%u freq=%f s^2epsilon=%f norm0=%f:\n",
+		 order, f, e,
+		 gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+	g_print ("H%u(z)=%s/%s\n", order,
+		 gsl_poly_str (order, a, "z"),
+		 gsl_poly_str (order, b, "z"));
+      }
+    }
+  else if (strcmp (argv[1], "t2") == 0)
+    {
+      guint order;
+      double fc, fr, e;
+      if (argc != 6)
+	usage ("t1 <order> <freqc> <freqr> <epsilon>");
+      order = atoi (argv[2]);
+      fc = atof (argv[3]);
+      fr = atof (argv[4]);
+      e = atof (argv[5]);
+      fc *= GSL_PI / 2.;
+      fr *= GSL_PI / 2.;
+      e = gsl_trans_zepsilon2ss (e);
+      {
+	double a[order + 1], b[order + 1];
+	gsl_filter_tscheb2 (order, fc, fr, e, a, b);
+	g_print ("# Tschebyscheff Type2 order=%u freq_c=%f freq_r=%f s^2epsilon=%f norm=%f:\n",
+		 order, fc, fr, e,
+		 gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+	g_print ("H%u(z)=%s/%s\n", order,
+		 gsl_poly_str (order, a, "z"),
+		 gsl_poly_str (order, b, "z"));
+      }
+    }
+  else if (strncmp (argv[1], "test", 4) == 0)
+    {
+      guint order;
+      arg = argv[1] + 4;
+      if (argc != argc)
+	usage ("test");
+      order = 2;
+      {
+	double a[100] = { 1, 2, 1 }, b[100] = { 1, -3./2., 0.5 };
+	g_print ("# Test order=%u  norm=%f:\n",
+		 order,
+		 gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+	g_print ("H%u(z)=%s/%s\n", order,
+		 gsl_poly_str (order, a, "z"),
+		 gsl_poly_str (order, b, "z"));
+	if (*arg)
+	  {
+	    GslComplex root, roots[100];
+	    guint i;
+
+	    if (*arg == 'r')
+	      {
+		g_print ("#roots:\n");
+		gsl_poly_complex_roots (order, a, roots);
+		for (i = 0; i < order; i++)
+		  {
+		    root = gsl_complex_div (gsl_complex (1, 0), roots[i]);
+		    g_print ("%+.14f %+.14f # %.14f\n", root.re, root.im, gsl_complex_abs (root));
+		  }
+	      }
+	    if (*arg == 'p')
+	      {
+		g_print ("#poles:\n");
+		gsl_poly_complex_roots (order, b, roots);
+		for (i = 0; i < order; i++)
+		  {
+		    root = gsl_complex_div (gsl_complex (1, 0), roots[i]);
+		    g_print ("%+.14f %+.14f # %.14f\n", root.re, root.im, gsl_complex_abs (root));
+		  }
+	      }
+	  }
+      }
+    }
+  else
+    {
+    abort:
+      usage ("{rf|F|sn|snc|sci_sn|sci_snc|asn|asnc|sci_asn|sci_asnc|sin(h)|cos(h)|tan(h)|t1|t2} ...");
+    }
+      
+  return 0;
+}
diff --git a/flow/gsl/gslopmaster.c b/flow/gsl/gslopmaster.c
new file mode 100644
index 0000000..f71ec3d
--- /dev/null
+++ b/flow/gsl/gslopmaster.c
@@ -0,0 +1,783 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include <string.h>
+#include <sys/poll.h>
+#include <sys/time.h>
+#include <errno.h>
+
+#include "gslopmaster.h"
+
+#include "gslcommon.h"
+#include "gslopnode.h"
+#include "gsloputil.h"
+#include "gslopschedule.h"
+#include "gslieee754.h"
+
+
+
+#define	NODE_FLAG_RECONNECT(node)	G_STMT_START { (node)->reconnected = (node)->module.klass->reconnect != NULL; } G_STMT_END
+
+
+/* --- time stamping (debugging) --- */
+#define	ToyprofStamp		struct timeval
+#define	toyprof_clock_name()	("Glibc gettimeofday(2)")
+#define toyprof_stampinit()	/* nothing */
+#define	toyprof_stamp(st)	gettimeofday (&(st), 0)
+#define	toyprof_stamp_ticks()	(1000000)
+static inline guint64
+toyprof_elapsed (ToyprofStamp fstamp,
+		 ToyprofStamp lstamp)
+{
+  guint64 first = fstamp.tv_sec * toyprof_stamp_ticks () + fstamp.tv_usec;
+  guint64 last  = lstamp.tv_sec * toyprof_stamp_ticks () + lstamp.tv_usec;
+  return last - first;
+}
+
+
+/* --- typedefs & structures --- */
+typedef struct _Poll Poll;
+struct _Poll
+{
+  Poll	     *next;
+  GslPollFunc poll_func;
+  gpointer    data;
+  guint       n_fds;
+  GPollFD    *fds;
+  GslFreeFunc free_func;
+};
+
+
+/* --- prototypes --- */
+static void	master_schedule_discard	(void);
+
+
+/* --- variables --- */
+static gboolean	       master_need_reflow = FALSE;
+static gboolean	       master_need_process = FALSE;
+static EngineNode     *master_consumer_list = NULL;
+const gfloat           gsl_engine_master_zero_block[GSL_STREAM_MAX_VALUES] = { 0, }; /* FIXME */
+static Poll	      *master_poll_list = NULL;
+static guint           master_n_pollfds = 0;
+static guint           master_pollfds_changed = FALSE;
+static GPollFD         master_pollfds[GSL_ENGINE_MAX_POLLFDS];
+static EngineSchedule *master_schedule = NULL;
+
+
+/* --- functions --- */
+static void
+add_consumer (EngineNode *node)
+{
+  g_return_if_fail (ENGINE_NODE_IS_CONSUMER (node) && node->toplevel_next == NULL && node->integrated);
+  
+  node->toplevel_next = master_consumer_list;
+  master_consumer_list = node;
+}
+
+static void
+remove_consumer (EngineNode *node)
+{
+  EngineNode *tmp, *last = NULL;
+  
+  g_return_if_fail (!ENGINE_NODE_IS_CONSUMER (node) || !node->integrated);
+  
+  for (tmp = master_consumer_list; tmp; last = tmp, tmp = last->toplevel_next)
+    if (tmp == node)
+      break;
+  g_return_if_fail (tmp != NULL);
+  if (last)
+    last->toplevel_next = node->toplevel_next;
+  else
+    master_consumer_list = node->toplevel_next;
+  node->toplevel_next = NULL;
+}
+
+static void
+master_idisconnect_node (EngineNode *node,
+			 guint       istream)
+{
+  EngineNode *src_node = node->inputs[istream].src_node;
+  guint ostream = node->inputs[istream].src_stream;
+  gboolean was_consumer;
+  
+  g_assert (ostream < ENGINE_NODE_N_OSTREAMS (src_node) &&
+	    src_node->outputs[ostream].n_outputs > 0);	/* these checks better pass */
+  
+  node->inputs[istream].src_node = NULL;
+  node->inputs[istream].src_stream = ~0;
+  node->module.istreams[istream].connected = FALSE;
+  was_consumer = ENGINE_NODE_IS_CONSUMER (src_node);
+  src_node->outputs[ostream].n_outputs -= 1;
+  src_node->module.ostreams[ostream].connected = src_node->outputs[ostream].n_outputs > 0;
+  src_node->output_nodes = gsl_ring_remove (src_node->output_nodes, node);
+  NODE_FLAG_RECONNECT (node);
+  NODE_FLAG_RECONNECT (src_node);
+  /* add to consumer list */
+  if (!was_consumer && ENGINE_NODE_IS_CONSUMER (src_node))
+    add_consumer (src_node);
+}
+
+static void
+master_jdisconnect_node (EngineNode *node,
+			 guint       jstream,
+			 guint       con)
+{
+  EngineNode *src_node = node->jinputs[jstream][con].src_node;
+  guint i, ostream = node->jinputs[jstream][con].src_stream;
+  gboolean was_consumer;
+  
+  g_assert (ostream < ENGINE_NODE_N_OSTREAMS (src_node) &&
+	    node->module.jstreams[jstream].n_connections > 0 &&
+	    src_node->outputs[ostream].n_outputs > 0);	/* these checks better pass */
+  
+  i = --node->module.jstreams[jstream].n_connections;
+  node->jinputs[jstream][con] = node->jinputs[jstream][i];
+  node->module.jstreams[jstream].values[i] = NULL; /* float**values 0-termination */
+  was_consumer = ENGINE_NODE_IS_CONSUMER (src_node);
+  src_node->outputs[ostream].n_outputs -= 1;
+  src_node->module.ostreams[ostream].connected = src_node->outputs[ostream].n_outputs > 0;
+  src_node->output_nodes = gsl_ring_remove (src_node->output_nodes, node);
+  NODE_FLAG_RECONNECT (node);
+  NODE_FLAG_RECONNECT (src_node);
+  /* add to consumer list */
+  if (!was_consumer && ENGINE_NODE_IS_CONSUMER (src_node))
+    add_consumer (src_node);
+}
+
+static void
+master_disconnect_node_outputs (EngineNode *src_node,
+				EngineNode *dest_node)
+{
+  gint i, j;
+  
+  for (i = 0; i < ENGINE_NODE_N_ISTREAMS (dest_node); i++)
+    if (dest_node->inputs[i].src_node == src_node)
+      master_idisconnect_node (dest_node, i);
+  for (j = 0; j < ENGINE_NODE_N_JSTREAMS (dest_node); j++)
+    for (i = 0; i < dest_node->module.jstreams[j].n_connections; i++)
+      if (dest_node->jinputs[j][i].src_node == src_node)
+	master_jdisconnect_node (dest_node, j, i--);
+}
+
+static void
+master_process_job (GslJob *job)
+{
+  switch (job->job_id)
+    {
+      EngineNode *node, *src_node;
+      Poll *poll, *poll_last;
+      guint istream, jstream, ostream, con;
+      EngineFlowJob *fjob;
+      gboolean was_consumer;
+    case ENGINE_JOB_INTEGRATE:
+      node = job->data.node;
+      JOB_DEBUG ("integrate(%p)", node);
+      g_return_if_fail (node->integrated == FALSE);
+      g_return_if_fail (node->sched_tag == FALSE);
+      _engine_mnl_integrate (node);
+      if (ENGINE_NODE_IS_CONSUMER (node))
+	add_consumer (node);
+      node->counter = 0;
+      NODE_FLAG_RECONNECT (node);
+      master_need_reflow |= TRUE;
+      break;
+    case ENGINE_JOB_DISCARD:
+      /* FIXME: free pending flow jobs */
+      node = job->data.node;
+      JOB_DEBUG ("discard(%p)", node);
+      g_return_if_fail (node->integrated == TRUE);
+      /* disconnect inputs */
+      for (istream = 0; istream < ENGINE_NODE_N_ISTREAMS (node); istream++)
+	if (node->inputs[istream].src_node)
+	  master_idisconnect_node (node, istream);
+      for (jstream = 0; jstream < ENGINE_NODE_N_JSTREAMS (node); jstream++)
+	while (node->module.jstreams[jstream].n_connections)
+	  master_jdisconnect_node (node, jstream, node->module.jstreams[jstream].n_connections - 1);
+      /* disconnect outputs */
+      while (node->output_nodes)
+	master_disconnect_node_outputs (node, node->output_nodes->data);
+      /* remove from consumer list */
+      if (ENGINE_NODE_IS_CONSUMER (node))
+	{
+	  _engine_mnl_remove (node);
+	  remove_consumer (node);
+	}
+      else
+	_engine_mnl_remove (node);
+      node->counter = 0;
+      master_need_reflow |= TRUE;
+      master_schedule_discard ();	/* discard schedule so node may be freed */
+      break;
+    case ENGINE_JOB_SET_CONSUMER:
+    case ENGINE_JOB_UNSET_CONSUMER:
+      node = job->data.node;
+      JOB_DEBUG ("toggle_consumer(%p)", node);
+      was_consumer = ENGINE_NODE_IS_CONSUMER (node);
+      node->is_consumer = job->job_id == ENGINE_JOB_SET_CONSUMER;
+      if (was_consumer != ENGINE_NODE_IS_CONSUMER (node))
+	{
+	  if (ENGINE_NODE_IS_CONSUMER (node))
+	    add_consumer (node);
+	  else
+	    remove_consumer (node);
+	  master_need_reflow |= TRUE;
+	}
+      break;
+    case ENGINE_JOB_ICONNECT:
+      node = job->data.connection.dest_node;
+      src_node = job->data.connection.src_node;
+      istream = job->data.connection.dest_ijstream;
+      ostream = job->data.connection.src_ostream;
+      JOB_DEBUG ("connect(%p,%u,%p,%u)", node, istream, src_node, ostream);
+      g_return_if_fail (node->integrated == TRUE);
+      g_return_if_fail (src_node->integrated == TRUE);
+      g_return_if_fail (node->inputs[istream].src_node == NULL);
+      node->inputs[istream].src_node = src_node;
+      node->inputs[istream].src_stream = ostream;
+      node->module.istreams[istream].connected = TRUE;
+      /* remove from consumer list */
+      was_consumer = ENGINE_NODE_IS_CONSUMER (src_node);
+      src_node->outputs[ostream].n_outputs += 1;
+      src_node->module.ostreams[ostream].connected = TRUE;
+      src_node->output_nodes = gsl_ring_append (src_node->output_nodes, node);
+      NODE_FLAG_RECONNECT (node);
+      NODE_FLAG_RECONNECT (src_node);
+      src_node->counter = 0;	/* FIXME: counter reset? */
+      if (was_consumer && !ENGINE_NODE_IS_CONSUMER (src_node))
+	remove_consumer (src_node);
+      master_need_reflow |= TRUE;
+      break;
+    case ENGINE_JOB_JCONNECT:
+      node = job->data.connection.dest_node;
+      src_node = job->data.connection.src_node;
+      jstream = job->data.connection.dest_ijstream;
+      ostream = job->data.connection.src_ostream;
+      JOB_DEBUG ("jconnect(%p,%u,%p,%u)", node, jstream, src_node, ostream);
+      g_return_if_fail (node->integrated == TRUE);
+      g_return_if_fail (src_node->integrated == TRUE);
+      con = node->module.jstreams[jstream].n_connections++;
+      node->jinputs[jstream] = g_renew (EngineJInput, node->jinputs[jstream], node->module.jstreams[jstream].n_connections);
+      node->module.jstreams[jstream].values = g_renew (const gfloat*, node->module.jstreams[jstream].values, node->module.jstreams[jstream].n_connections + 1);
+      node->module.jstreams[jstream].values[node->module.jstreams[jstream].n_connections] = NULL; /* float**values 0-termination */
+      node->jinputs[jstream][con].src_node = src_node;
+      node->jinputs[jstream][con].src_stream = ostream;
+      /* remove from consumer list */
+      was_consumer = ENGINE_NODE_IS_CONSUMER (src_node);
+      src_node->outputs[ostream].n_outputs += 1;
+      src_node->module.ostreams[ostream].connected = TRUE;
+      src_node->output_nodes = gsl_ring_append (src_node->output_nodes, node);
+      NODE_FLAG_RECONNECT (node);
+      NODE_FLAG_RECONNECT (src_node);
+      src_node->counter = 0;	/* FIXME: counter reset? */
+      if (was_consumer && !ENGINE_NODE_IS_CONSUMER (src_node))
+	remove_consumer (src_node);
+      master_need_reflow |= TRUE;
+      break;
+    case ENGINE_JOB_IDISCONNECT:
+      node = job->data.connection.dest_node;
+      JOB_DEBUG ("idisconnect(%p,%u)", node, job->data.connection.dest_ijstream);
+      g_return_if_fail (node->integrated == TRUE);
+      g_return_if_fail (node->inputs[job->data.connection.dest_ijstream].src_node != NULL);
+      master_idisconnect_node (node, job->data.connection.dest_ijstream);
+      master_need_reflow |= TRUE;
+      break;
+    case ENGINE_JOB_JDISCONNECT:
+      node = job->data.connection.dest_node;
+      jstream = job->data.connection.dest_ijstream;
+      src_node = job->data.connection.src_node;
+      ostream = job->data.connection.src_ostream;
+      JOB_DEBUG ("jdisconnect(%p,%u,%p,%u)", node, jstream, src_node, ostream);
+      g_return_if_fail (node->integrated == TRUE);
+      g_return_if_fail (node->module.jstreams[jstream].n_connections > 0);
+      for (con = 0; con < node->module.jstreams[jstream].n_connections; con++)
+	if (node->jinputs[jstream][con].src_node == src_node &&
+	    node->jinputs[jstream][con].src_stream == ostream)
+	  break;
+      if (con < node->module.jstreams[jstream].n_connections)
+	{
+	  master_jdisconnect_node (node, jstream, con);
+	  master_need_reflow |= TRUE;
+	}
+      else
+	g_warning ("jdisconnect(dest:%p,%u,src:%p,%u): no such connection", node, jstream, src_node, ostream);
+      break;
+    case ENGINE_JOB_ACCESS:
+      node = job->data.access.node;
+      JOB_DEBUG ("access node(%p): %p(%p)", node, job->data.access.access_func, job->data.access.data);
+      g_return_if_fail (node->integrated == TRUE);
+      job->data.access.access_func (&node->module, job->data.access.data);
+      break;
+    case ENGINE_JOB_FLOW_JOB:
+      node = job->data.flow_job.node;
+      fjob = job->data.flow_job.fjob;
+      JOB_DEBUG ("add flow_job(%p,%p)", node, fjob);
+      g_return_if_fail (node->integrated == TRUE);
+      job->data.flow_job.fjob = NULL;	/* ownership taken over */
+      _engine_node_insert_flow_job (node, fjob);
+      _engine_mnl_reorder (node);
+      break;
+    case ENGINE_JOB_DEBUG:
+      JOB_DEBUG ("debug");
+      g_printerr ("JOB-DEBUG: %s\n", job->data.debug);
+      break;
+    case ENGINE_JOB_ADD_POLL:
+      JOB_DEBUG ("add poll %p(%p,%u)", job->data.poll.poll_func, job->data.poll.data, job->data.poll.n_fds);
+      if (job->data.poll.n_fds + master_n_pollfds > GSL_ENGINE_MAX_POLLFDS)
+	g_error ("adding poll job exceeds maximum number of poll-fds (%u > %u)",
+		 job->data.poll.n_fds + master_n_pollfds, GSL_ENGINE_MAX_POLLFDS);
+      poll = gsl_new_struct0 (Poll, 1);
+      poll->poll_func = job->data.poll.poll_func;
+      poll->data = job->data.poll.data;
+      poll->free_func = job->data.poll.free_func;
+      job->data.poll.free_func = NULL;		/* don't free data this round */
+      poll->n_fds = job->data.poll.n_fds;
+      poll->fds = poll->n_fds ? master_pollfds + master_n_pollfds : master_pollfds;
+      master_n_pollfds += poll->n_fds;
+      if (poll->n_fds)
+	master_pollfds_changed = TRUE;
+      memcpy (poll->fds, job->data.poll.fds, sizeof (poll->fds[0]) * poll->n_fds);
+      poll->next = master_poll_list;
+      master_poll_list = poll;
+      break;
+    case ENGINE_JOB_REMOVE_POLL:
+      JOB_DEBUG ("remove poll %p(%p)", job->data.poll.poll_func, job->data.poll.data);
+      for (poll = master_poll_list, poll_last = NULL; poll; poll_last = poll, poll = poll_last->next)
+	if (poll->poll_func == job->data.poll.poll_func && poll->data == job->data.poll.data)
+	  {
+	    if (poll_last)
+	      poll_last->next = poll->next;
+	    else
+	      master_poll_list = poll->next;
+	    break;
+	  }
+      if (poll)
+	{
+	  job->data.poll.free_func = poll->free_func;	/* free data with job */
+	  poll_last = poll;
+	  if (poll_last->n_fds)
+	    {
+	      for (poll = master_poll_list; poll; poll = poll->next)
+		if (poll->fds > poll_last->fds)
+		  poll->fds -= poll_last->n_fds;
+	      g_memmove (poll_last->fds, poll_last->fds + poll_last->n_fds,
+			 ((guint8*) (master_pollfds + master_n_pollfds)) -
+			 ((guint8*) (poll_last->fds + poll_last->n_fds)));
+	      master_n_pollfds -= poll_last->n_fds;
+	      master_pollfds_changed = TRUE;
+	    }
+	  gsl_delete_struct (Poll, poll_last);
+	}
+      else
+	g_warning (G_STRLOC ": failed to remove unknown poll function %p(%p)",
+		   job->data.poll.poll_func, job->data.poll.data);
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+  JOB_DEBUG ("done");
+}
+
+static void
+master_poll_check (glong   *timeout_p,
+		   gboolean check_with_revents)
+{
+  gboolean need_processing = FALSE;
+  Poll *poll;
+  
+  if (master_need_process || *timeout_p == 0)
+    {
+      master_need_process = TRUE;
+      return;
+    }
+  for (poll = master_poll_list; poll; poll = poll->next)
+    {
+      glong timeout = -1;
+      
+      if (poll->poll_func (poll->data, gsl_engine_block_size (), &timeout,
+			   poll->n_fds, poll->n_fds ? poll->fds : NULL, check_with_revents)
+	  || timeout == 0)
+	{
+	  need_processing |= TRUE;
+	  *timeout_p = 0;
+	  break;
+	}
+      else if (timeout > 0)
+	*timeout_p = *timeout_p < 0 ? timeout : MIN (*timeout_p, timeout);
+    }
+  master_need_process = need_processing;
+}
+
+static inline guint64
+master_handle_flow_jobs (EngineNode *node,
+			 guint64     max_tick)
+{
+  EngineFlowJob *fjob = _engine_node_pop_flow_job (node, max_tick);
+  
+  if_reject (fjob)
+    do
+      {
+	g_printerr ("FJob: at:%lld from:%lld \n", node->counter, fjob->any.tick_stamp);
+	switch (fjob->fjob_id)
+	  {
+	  case ENGINE_FLOW_JOB_ACCESS:
+	    fjob->access.access_func (&node->module, fjob->access.data);
+	    break;
+	  default:
+	    g_assert_not_reached (); /* FIXME */
+	  }
+	fjob = _engine_node_pop_flow_job (node, max_tick);
+      }
+    while (fjob);
+  
+  return _engine_node_peek_flow_job_stamp (node);
+}
+
+static void
+master_process_locked_node (EngineNode *node,
+			    guint       n_values)
+{
+  guint64 final_counter = GSL_TICK_STAMP + n_values;
+  
+  while (node->counter < final_counter)
+    {
+      guint64 next_counter = master_handle_flow_jobs (node, node->counter);
+      guint64 new_counter = MIN (next_counter, final_counter);
+      guint i, j, diff = node->counter - GSL_TICK_STAMP;
+      
+      for (i = 0; i < ENGINE_NODE_N_ISTREAMS (node); i++)
+	{
+	  EngineNode *inode = node->inputs[i].src_node;
+	  
+	  if (inode)
+	    {
+	      ENGINE_NODE_LOCK (inode);
+	      if (inode->counter < final_counter)
+		master_process_locked_node (inode, final_counter - node->counter);
+	      node->module.istreams[i].values = inode->outputs[node->inputs[i].src_stream].buffer;
+	      node->module.istreams[i].values += diff;
+	      ENGINE_NODE_UNLOCK (inode);
+	    }
+	  else
+	    node->module.istreams[i].values = gsl_engine_master_zero_block;
+	}
+      for (j = 0; j < ENGINE_NODE_N_JSTREAMS (node); j++)
+	for (i = 0; i < node->module.jstreams[j].n_connections; i++)
+	  {
+	    EngineNode *inode = node->jinputs[j][i].src_node;
+	    
+	    ENGINE_NODE_LOCK (inode);
+	    if (inode->counter < final_counter)
+	      master_process_locked_node (inode, final_counter - node->counter);
+	    node->module.jstreams[j].values[i] = inode->outputs[node->jinputs[j][i].src_stream].buffer;
+	    node->module.jstreams[j].values[i] += diff;
+	    ENGINE_NODE_UNLOCK (inode);
+	  }
+      for (i = 0; i < ENGINE_NODE_N_OSTREAMS (node); i++)
+	node->module.ostreams[i].values = node->outputs[i].buffer + diff;
+      if_reject (node->reconnected)
+	{
+	  node->module.klass->reconnect (&node->module);
+	  node->reconnected = FALSE;
+	}
+      node->module.klass->process (&node->module, new_counter - node->counter);
+      for (i = 0; i < ENGINE_NODE_N_OSTREAMS (node); i++)
+	{
+	  /* FIXME: this takes the worst possible performance hit to support virtualization */
+	  if (node->module.ostreams[i].values != node->outputs[i].buffer + diff)
+	    memcpy (node->outputs[i].buffer + diff, node->module.ostreams[i].values,
+		    (new_counter - node->counter) * sizeof (gfloat));
+	}
+      node->counter = new_counter;
+    }
+}
+
+static GslLong gsl_profile_modules = 0;	/* set to 1 in gdb to get profile output */
+
+static void
+master_process_flow (void)
+{
+  guint64 new_counter = GSL_TICK_STAMP + gsl_engine_block_size ();
+  GslLong profile_maxtime = 0;
+  GslLong profile_modules = gsl_profile_modules;
+  EngineNode *profile_node = NULL;
+  
+  g_return_if_fail (master_need_process == TRUE);
+  
+  g_assert (gsl_fpu_okround () == TRUE);
+  
+  MAS_DEBUG ("process_flow");
+  if (master_schedule)
+    {
+      EngineNode *node;
+      
+      _engine_schedule_restart (master_schedule);
+      _engine_set_schedule (master_schedule);
+      
+      node = _engine_pop_unprocessed_node ();
+      while (node)
+	{
+	  ToyprofStamp profile_stamp1, profile_stamp2;
+	  
+	  if_reject (profile_modules)
+	    toyprof_stamp (profile_stamp1);
+	  
+	  master_process_locked_node (node, gsl_engine_block_size ());
+	  
+	  if_reject (profile_modules)
+	    {
+	      GslLong duration;
+	      
+	      toyprof_stamp (profile_stamp2);
+	      duration = toyprof_elapsed (profile_stamp1, profile_stamp2);
+	      if (duration > profile_maxtime)
+		{
+		  profile_maxtime = duration;
+		  profile_node = node;
+		}
+	    }
+	  
+	  _engine_push_processed_node (node);
+	  node = _engine_pop_unprocessed_node ();
+	}
+      
+      if_reject (profile_modules)
+	{
+	  if (profile_node)
+	    {
+	      if (profile_maxtime > profile_modules)
+		g_print ("Excess Node: %p  Duration: %lu usecs     ((void(*)())%p)         \n",
+			 profile_node, profile_maxtime, profile_node->module.klass->process);
+	      else
+		g_print ("Slowest Node: %p  Duration: %lu usecs     ((void(*)())%p)         \r",
+			 profile_node, profile_maxtime, profile_node->module.klass->process);
+	    }
+	}
+      
+      /* walk unscheduled nodes which have flow jobs */
+      node = _engine_mnl_head ();
+      while (node && GSL_MNL_HEAD_NODE (node))
+	{
+	  EngineNode *tmp = node->mnl_next;
+	  EngineFlowJob *fjob = _engine_node_pop_flow_job (node, new_counter);
+	  
+	  if (fjob)
+	    {
+	      while (fjob)
+		{
+		  g_printerr ("ignoring flow_job %p\n", fjob);
+		  fjob = _engine_node_pop_flow_job (node, new_counter);
+		}
+	      _engine_mnl_reorder (node);
+	    }
+	  node = tmp;
+	}
+      
+      /* nothing new to process, wait on slaves */
+      _engine_wait_on_unprocessed ();
+      
+      _engine_unset_schedule (master_schedule);
+      _gsl_tick_stamp_inc ();
+      _engine_recycle_const_values ();
+    }
+  master_need_process = FALSE;
+}
+
+static void
+master_reschedule_flow (void)
+{
+  EngineNode *node;
+  
+  g_return_if_fail (master_need_reflow == TRUE);
+  
+  MAS_DEBUG ("flow_reschedule");
+  if (!master_schedule)
+    master_schedule = _engine_schedule_new ();
+  else
+    {
+      _engine_schedule_unsecure (master_schedule);
+      _engine_schedule_clear (master_schedule);
+    }
+  for (node = master_consumer_list; node; node = node->toplevel_next)
+    _engine_schedule_consumer_node (master_schedule, node);
+  _engine_schedule_secure (master_schedule);
+  master_need_reflow = FALSE;
+}
+
+static void
+master_schedule_discard (void)
+{
+  g_return_if_fail (master_need_reflow == TRUE);
+  
+  if (master_schedule)
+    {
+      _engine_schedule_unsecure (master_schedule);
+      _engine_schedule_destroy (master_schedule);
+      master_schedule = NULL;
+    }
+}
+
+
+/* --- MasterThread main loop --- */
+gboolean
+_engine_master_prepare (GslEngineLoop *loop)
+{
+  gboolean need_dispatch;
+  guint i;
+  
+  g_return_val_if_fail (loop != NULL, FALSE);
+  
+  /* setup and clear pollfds here already, so master_poll_check() gets no junk (and IRIX can't handle non-0 revents) */
+  loop->fds_changed = master_pollfds_changed;
+  master_pollfds_changed = FALSE;
+  loop->n_fds = master_n_pollfds;
+  loop->fds = master_pollfds;
+  for (i = 0; i < loop->n_fds; i++)
+    loop->fds[i].revents = 0;
+  loop->revents_filled = FALSE;
+  
+  loop->timeout = -1;
+  /* cached checks first */
+  need_dispatch = master_need_reflow || master_need_process;
+  /* lengthy query */
+  if (!need_dispatch)
+    need_dispatch = _engine_job_pending ();
+  /* invoke custom poll checks */
+  if (!need_dispatch)
+    {
+      master_poll_check (&loop->timeout, FALSE);
+      need_dispatch = master_need_process;
+    }
+  if (need_dispatch)
+    loop->timeout = 0;
+  
+  MAS_DEBUG ("PREPARE: need_dispatch=%u timeout=%6ld n_fds=%u",
+	     need_dispatch,
+	     loop->timeout, loop->n_fds);
+  
+  return need_dispatch;
+}
+
+gboolean
+_engine_master_check (const GslEngineLoop *loop)
+{
+  gboolean need_dispatch;
+  
+  g_return_val_if_fail (loop != NULL, FALSE);
+  g_return_val_if_fail (loop->n_fds == master_n_pollfds, FALSE);
+  g_return_val_if_fail (loop->fds == master_pollfds, FALSE);
+  if (loop->n_fds)
+    g_return_val_if_fail (loop->revents_filled == TRUE, FALSE);
+  
+  /* cached checks first */
+  need_dispatch = master_need_reflow || master_need_process;
+  /* lengthy query */
+  if (!need_dispatch)
+    need_dispatch = _engine_job_pending ();
+  /* invoke custom poll checks */
+  if (!need_dispatch)
+    {
+      glong dummy = -1;
+      
+      master_poll_check (&dummy, TRUE);
+      need_dispatch = master_need_process;
+    }
+  
+  MAS_DEBUG ("CHECK: need_dispatch=%u", need_dispatch);
+  
+  return need_dispatch;
+}
+
+void
+_engine_master_dispatch_jobs (void)
+{
+  GslJob *job;
+  
+  job = _engine_pop_job ();
+  while (job)
+    {
+      master_process_job (job);
+      job = _engine_pop_job ();	/* have to process _all_ jobs */
+    }
+}
+
+void
+_engine_master_dispatch (void)
+{
+  /* processing has prime priority, but we can't process the
+   * network, until all jobs have been handled and if necessary
+   * rescheduled the network.
+   * that's why we have to handle everything at once and can't
+   * preliminarily return after just handling jobs or rescheduling.
+   */
+  _engine_master_dispatch_jobs ();
+  if (master_need_reflow)
+    master_reschedule_flow ();
+  if (master_need_process)
+    master_process_flow ();
+}
+
+void
+_engine_master_thread (gpointer data)
+{
+  gboolean run = TRUE;
+  
+  /* assert sane configuration checks, since we're simply casting structures */
+  g_assert (sizeof (struct pollfd) == sizeof (GPollFD) &&
+	    G_STRUCT_OFFSET (GPollFD, fd) == G_STRUCT_OFFSET (struct pollfd, fd) &&
+	    G_STRUCT_OFFSET (GPollFD, events) == G_STRUCT_OFFSET (struct pollfd, events) &&
+	    G_STRUCT_OFFSET (GPollFD, revents) == G_STRUCT_OFFSET (struct pollfd, revents));
+  
+  /* add the thread wakeup pipe to master pollfds, so we get woken
+   * up in time (even though we evaluate the pipe contents later)
+   */
+  gsl_thread_get_pollfd (master_pollfds);
+  master_n_pollfds += 1;
+  master_pollfds_changed = TRUE;
+  
+  toyprof_stampinit ();
+  
+  while (run)
+    {
+      GslEngineLoop loop;
+      gboolean need_dispatch;
+      
+      need_dispatch = _engine_master_prepare (&loop);
+      
+      if (!need_dispatch)
+	{
+	  gint err;
+	  
+	  err = poll ((struct pollfd*) loop.fds, loop.n_fds, loop.timeout);
+	  
+	  if (err >= 0)
+	    loop.revents_filled = TRUE;
+	  else
+	    g_printerr (G_STRLOC ": poll() error: %s\n", g_strerror (errno));
+	  
+	  if (loop.revents_filled)
+	    need_dispatch = _engine_master_check (&loop);
+	}
+      
+      if (need_dispatch)
+	_engine_master_dispatch ();
+      
+      /* handle thread pollfd messages */
+      run = gsl_thread_sleep (0);
+    }
+}
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gslopmaster.h b/flow/gsl/gslopmaster.h
new file mode 100644
index 0000000..69cc3f8
--- /dev/null
+++ b/flow/gsl/gslopmaster.h
@@ -0,0 +1,42 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_ENGINE_MASTER_H__
+#define __GSL_ENGINE_MASTER_H__
+
+#include	<gsl/gslengine.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- internal (EngineThread) --- */
+gboolean	_engine_master_prepare		(GslEngineLoop		*loop);
+gboolean	_engine_master_check		(const GslEngineLoop	*loop);
+void		_engine_master_dispatch_jobs	(void);
+void		_engine_master_dispatch		(void);
+void		_engine_master_thread		(gpointer		 data);
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_ENGINE_MASTER_H__ */
diff --git a/flow/gsl/gslopnode.h b/flow/gsl/gslopnode.h
new file mode 100644
index 0000000..3e236e5
--- /dev/null
+++ b/flow/gsl/gslopnode.h
@@ -0,0 +1,247 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_ENGINE_NODE_H__
+#define __GSL_ENGINE_NODE_H__
+
+#include "gslengine.h"
+#include "gsloputil.h"
+#include "gslcommon.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+
+#define	ENGINE_NODE(module)		((EngineNode*) (module))
+#define ENGINE_NODE_N_OSTREAMS(node)	((node)->module.klass->n_ostreams)
+#define ENGINE_NODE_N_ISTREAMS(node)	((node)->module.klass->n_istreams)
+#define ENGINE_NODE_N_JSTREAMS(node)	((node)->module.klass->n_jstreams)
+#define	ENGINE_NODE_IS_CONSUMER(node)	((node)->is_consumer && \
+					 (node)->output_nodes == NULL)
+#define	ENGINE_NODE_IS_DEFERRED(node)	(FALSE)
+#define	ENGINE_NODE_IS_SCHEDULED(node)	(ENGINE_NODE (node)->sched_tag)
+#define	ENGINE_NODE_IS_CHEAP(node)	(((node)->module.klass->mflags & GSL_COST_CHEAP) != 0)
+#define	ENGINE_NODE_IS_EXPENSIVE(node)	(((node)->module.klass->mflags & GSL_COST_EXPENSIVE) != 0)
+#define	ENGINE_NODE_LOCK(node)		gsl_rec_mutex_lock (&(node)->rec_mutex)
+#define	ENGINE_NODE_UNLOCK(node)	gsl_rec_mutex_unlock (&(node)->rec_mutex)
+
+
+/* --- debugging and messages --- */
+#define ENG_DEBUG		GSL_DEBUG_FUNCTION (GSL_MSG_ENGINE, NULL)
+#define MAS_DEBUG		GSL_DEBUG_FUNCTION (GSL_MSG_MASTER, NULL)
+#define JOB_DEBUG		GSL_DEBUG_FUNCTION (GSL_MSG_JOBS, NULL)
+#define SCHED_DEBUG		GSL_DEBUG_FUNCTION (GSL_MSG_SCHED, NULL)
+
+
+/* --- transactions --- */
+typedef union _EngineFlowJob EngineFlowJob;
+typedef enum {
+  ENGINE_JOB_NOP,
+  ENGINE_JOB_INTEGRATE,
+  ENGINE_JOB_DISCARD,
+  ENGINE_JOB_ICONNECT,
+  ENGINE_JOB_JCONNECT,
+  ENGINE_JOB_IDISCONNECT,
+  ENGINE_JOB_JDISCONNECT,
+  ENGINE_JOB_SET_CONSUMER,
+  ENGINE_JOB_UNSET_CONSUMER,
+  ENGINE_JOB_ACCESS,
+  ENGINE_JOB_ADD_POLL,
+  ENGINE_JOB_REMOVE_POLL,
+  ENGINE_JOB_FLOW_JOB,
+  ENGINE_JOB_DEBUG,
+  ENGINE_JOB_LAST
+} EngineJobType;
+struct _GslJob
+{
+  EngineJobType       job_id;
+  GslJob	     *next;
+  union {
+    EngineNode	     *node;
+    struct {
+      EngineNode     *dest_node;
+      guint	      dest_ijstream;
+      EngineNode     *src_node;
+      guint	      src_ostream;
+    } connection;
+    struct {
+      EngineNode     *node;
+      GslAccessFunc   access_func;
+      gpointer	      data;
+      GslFreeFunc     free_func;
+    } access;
+    struct {
+      GslPollFunc     poll_func;
+      gpointer	      data;
+      GslFreeFunc     free_func;
+      guint           n_fds;
+      GPollFD	     *fds;
+    } poll;
+    struct {
+      EngineNode     *node;
+      EngineFlowJob  *fjob;
+    } flow_job;
+    gchar	     *debug;
+  } data;
+};
+struct _GslTrans
+{
+  GslJob   *jobs_head;
+  GslJob   *jobs_tail;
+  guint	    comitted : 1;
+  GslTrans *cqt_next;	/* com-thread-queue */
+};
+typedef enum {
+  ENGINE_FLOW_JOB_NOP,
+  ENGINE_FLOW_JOB_SUSPEND,
+  ENGINE_FLOW_JOB_RESUME,
+  ENGINE_FLOW_JOB_ACCESS,
+  ENGINE_FLOW_JOB_LAST
+} EngineFlowJobType;
+typedef struct
+{
+  EngineFlowJobType fjob_id;
+  EngineFlowJob    *next;
+  guint64           tick_stamp;
+} EngineFlowJobAny;
+typedef struct
+{
+  EngineFlowJobType fjob_id;
+  EngineFlowJob	   *next;
+  guint64	    tick_stamp;
+  GslAccessFunc     access_func;
+  gpointer          data;
+  GslFreeFunc       free_func;
+} EngineFlowJobAccess;
+union _EngineFlowJob
+{
+  EngineFlowJobType   fjob_id;
+  EngineFlowJobAny    any;
+  EngineFlowJobAccess access;
+};
+
+
+/* --- module nodes --- */
+typedef struct
+{
+  EngineNode *src_node;
+  guint	      src_stream;	/* ostream of src_node */
+} EngineInput;
+typedef struct
+{
+  EngineNode *src_node;
+  guint	      src_stream;	/* ostream of src_node */
+} EngineJInput;
+typedef struct
+{
+  gfloat *buffer;
+  guint	  n_outputs;
+} EngineOutput;
+struct _EngineNode		/* fields sorted by order of processing access */
+{
+  GslModule	 module;
+
+  GslRecMutex	 rec_mutex;	/* processing lock */
+  guint64	 counter;	/* <= GSL_TICK_STAMP */
+  EngineInput	*inputs;	/* [ENGINE_NODE_N_ISTREAMS()] */
+  EngineJInput **jinputs;	/* [ENGINE_NODE_N_JSTREAMS()] */
+  EngineOutput	*outputs;	/* [ENGINE_NODE_N_OSTREAMS()] */
+
+  /* flow jobs */
+  EngineFlowJob	*flow_jobs;			/* active jobs */
+  EngineFlowJob	*fjob_first, *fjob_last;	/* trash list */
+
+  /* master-node-list */
+  EngineNode	*mnl_next;
+  EngineNode	*mnl_prev;
+  guint		 integrated : 1;
+  guint		 reconnected : 1;
+
+  guint		 is_consumer : 1;
+  
+  /* scheduler */
+  guint		 sched_tag : 1;
+  guint		 sched_router_tag : 1;
+  guint		 sched_leaf_level;
+  EngineNode	*toplevel_next;	/* master-consumer-list, FIXME: overkill, using a GslRing is good enough */
+  GslRing	*output_nodes;	/* EngineNode* ring of nodes in ->outputs[] */
+};
+
+static void
+_engine_node_insert_flow_job (EngineNode    *node,
+			      EngineFlowJob *fjob)
+{
+  EngineFlowJob *last = NULL, *tmp = node->flow_jobs;
+
+  /* find next position */
+  while (tmp && tmp->any.tick_stamp <= fjob->any.tick_stamp)
+    {
+      last = tmp;
+      tmp = last->any.next;
+    }
+  /* insert before */
+  fjob->any.next = tmp;
+  if (last)
+    last->any.next = fjob;
+  else
+    node->flow_jobs = fjob;
+}
+
+static inline EngineFlowJob*
+_engine_node_pop_flow_job (EngineNode *node,
+			   guint64     tick_stamp)
+{
+  EngineFlowJob *fjob = node->flow_jobs;
+
+  if_reject (fjob)
+    {
+      if (fjob->any.tick_stamp <= tick_stamp)
+	{
+	  node->flow_jobs = fjob->any.next;
+	  
+	  fjob->any.next = node->fjob_first;
+	  node->fjob_first = fjob;
+	  if (!node->fjob_last)
+	    node->fjob_last = node->fjob_first;
+	}
+      else
+	fjob = NULL;
+    }
+
+  return fjob;
+}
+
+static inline guint64
+_engine_node_peek_flow_job_stamp (EngineNode *node)
+{
+  EngineFlowJob *fjob = node->flow_jobs;
+
+  if_reject (fjob)
+    return fjob->any.tick_stamp;
+
+  return GSL_MAX_TICK_STAMP;
+}
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_ENGINE_NODE_H__ */
diff --git a/flow/gsl/gslopschedule.c b/flow/gsl/gslopschedule.c
new file mode 100644
index 0000000..9102a41
--- /dev/null
+++ b/flow/gsl/gslopschedule.c
@@ -0,0 +1,582 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslopschedule.h"
+
+
+#include "gslcommon.h"	
+
+
+/* --- functions --- */
+EngineSchedule*
+_engine_schedule_new (void)
+{
+  EngineSchedule *sched = gsl_new_struct0 (EngineSchedule, 1);
+  
+  sched->n_items = 0;
+  sched->leaf_levels = 0;
+  sched->nodes = NULL;
+  sched->cycles = NULL;
+  sched->secured = FALSE;
+  sched->in_pqueue = FALSE;
+  sched->cur_leaf_level = ~0;
+  sched->cur_node = NULL;
+  sched->cur_cycle = NULL;
+  
+  return sched;
+}
+
+static inline void
+unschedule_node (EngineSchedule *sched,
+		 EngineNode *node)
+{
+  guint leaf_level;
+  
+  g_return_if_fail (ENGINE_NODE_IS_SCHEDULED (node) == TRUE);
+  leaf_level = node->sched_leaf_level;
+  g_return_if_fail (leaf_level <= sched->leaf_levels);
+  g_return_if_fail (sched->n_items > 0);
+  
+  SCHED_DEBUG ("unschedule_node(%p,%u)", node, leaf_level);
+  sched->nodes[leaf_level] = gsl_ring_remove (sched->nodes[leaf_level], node);
+  node->sched_leaf_level = 0;
+  node->sched_tag = FALSE;
+  if (node->flow_jobs)
+    _engine_mnl_reorder (node);
+  sched->n_items--;
+}
+
+static inline void
+unschedule_cycle (EngineSchedule *sched,
+		  GslRing     *ring)
+{
+  guint leaf_level;
+  GslRing *walk;
+  
+  g_return_if_fail (ENGINE_NODE_IS_SCHEDULED (ENGINE_NODE (ring->data)) == TRUE);
+  leaf_level = ENGINE_NODE (ring->data)->sched_leaf_level;
+  g_return_if_fail (leaf_level <= sched->leaf_levels);
+  g_return_if_fail (sched->n_items > 0);
+  
+  SCHED_DEBUG ("unschedule_cycle(%p,%u,%p)", ring->data, leaf_level, ring);
+  sched->nodes[leaf_level] = gsl_ring_remove (sched->nodes[leaf_level], ring);
+  for (walk = ring; walk; walk = gsl_ring_walk (ring, walk))
+    {
+      EngineNode *node = walk->data;
+      
+      if (!ENGINE_NODE_IS_SCHEDULED (node))
+	g_warning ("node(%p) in schedule ring(%p) is untagged", node, ring);
+      node->sched_leaf_level = 0;
+      node->sched_tag = FALSE;
+      if (node->flow_jobs)
+	_engine_mnl_reorder (node);
+    }
+  sched->n_items--;
+}
+
+static void
+_engine_schedule_debug_dump (EngineSchedule *sched)
+{
+  g_printerr ("sched(%p) = {\n", sched);
+  if (sched)
+    {
+      guint i;
+      
+      g_printerr ("  n_items=%u, leaf_levels=%u, secured=%u,\n",
+		  sched->n_items, sched->leaf_levels, sched->secured);
+      g_printerr ("  in_pqueue=%u, cur_leaf_level=%u,\n",
+		  sched->in_pqueue, sched->cur_leaf_level);
+      g_printerr ("  cur_node=%p, cur_cycle=%p,\n",
+		  sched->cur_node, sched->cur_cycle);
+      for (i = 0; i < sched->leaf_levels; i++)
+	{
+	  GslRing *ring, *head = sched->nodes[i];
+	  
+	  if (!head)
+	    continue;
+	  g_printerr ("  { leaf_level=%u:", i);
+	  for (ring = head; ring; ring = gsl_ring_walk (head, ring))
+	    g_printerr (" node(%p(tag:%u))", ring->data, ((EngineNode*) ring->data)->sched_tag);
+	  g_printerr (" },\n");
+	}
+    }
+  g_printerr ("};\n");
+}
+
+
+void
+_engine_schedule_clear (EngineSchedule *sched)
+{
+  guint i;
+  
+  g_return_if_fail (sched != NULL);
+  g_return_if_fail (sched->secured == FALSE);
+  g_return_if_fail (sched->in_pqueue == FALSE);
+  
+  for (i = 0; i < sched->leaf_levels; i++)
+    {
+      /* FIXME: each unschedule operation is a list walk, while we
+       * could easily leave the rings alone and free them as a whole
+       */
+      while (sched->nodes[i])
+	unschedule_node (sched, sched->nodes[i]->data);
+      while (sched->cycles[i])
+	unschedule_cycle (sched, sched->cycles[i]->data);
+    }
+  g_return_if_fail (sched->n_items == 0);
+}
+
+void
+_engine_schedule_destroy (EngineSchedule *sched)
+{
+  g_return_if_fail (sched != NULL);
+  g_return_if_fail (sched->secured == FALSE);
+  g_return_if_fail (sched->in_pqueue == FALSE);
+  
+  _engine_schedule_clear (sched);
+  g_free (sched->nodes);
+  g_free (sched->cycles);
+  gsl_delete_struct (EngineSchedule, sched);
+}
+
+static void
+_engine_schedule_grow (EngineSchedule *sched,
+		       guint           leaf_level)
+{
+  guint ll = 1 << g_bit_storage (leaf_level);	/* power2 growth alignment, ll >= leaf_level+1 */
+  
+  if (sched->leaf_levels < ll)
+    {
+      guint i = sched->leaf_levels;
+      
+      sched->leaf_levels = ll;
+      sched->nodes = g_renew (GslRing*, sched->nodes, sched->leaf_levels);
+      sched->cycles = g_renew (GslRing*, sched->cycles, sched->leaf_levels);
+      for (; i < sched->leaf_levels; i++)
+	{
+	  sched->nodes[i] = NULL;
+	  sched->cycles[i] = NULL;
+	}
+    }
+}
+
+void
+_engine_schedule_node (EngineSchedule *sched,
+		       EngineNode     *node,
+		       guint           leaf_level)
+{
+  g_return_if_fail (sched != NULL);
+  g_return_if_fail (sched->secured == FALSE);
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (!ENGINE_NODE_IS_SCHEDULED (node));
+  
+  SCHED_DEBUG ("schedule_node(%p,%u)", node, leaf_level);
+  node->sched_leaf_level = leaf_level;
+  node->sched_tag = TRUE;
+  if (node->flow_jobs)
+    _engine_mnl_reorder (node);
+  _engine_schedule_grow (sched, leaf_level);
+  /* could do 3-stage scheduling by expensiveness */
+  sched->nodes[leaf_level] = (ENGINE_NODE_IS_EXPENSIVE (node) ? gsl_ring_prepend : gsl_ring_append) (sched->nodes[leaf_level], node);
+  sched->n_items++;
+}
+
+void
+_engine_schedule_cycle (EngineSchedule *sched,
+			GslRing        *cycle_nodes,
+			guint           leaf_level)
+{
+  GslRing *walk;
+  
+  g_return_if_fail (sched != NULL);
+  g_return_if_fail (sched->secured == FALSE);
+  g_return_if_fail (cycle_nodes != NULL);
+  
+  for (walk = cycle_nodes; walk; walk = gsl_ring_walk (cycle_nodes, walk))
+    {
+      EngineNode *node = walk->data;
+      
+      g_return_if_fail (!ENGINE_NODE_IS_SCHEDULED (node));
+      node->sched_leaf_level = leaf_level;
+      node->sched_tag = TRUE;
+      if (node->flow_jobs)
+	_engine_mnl_reorder (node);
+    }
+  _engine_schedule_grow (sched, leaf_level);
+  sched->cycles[leaf_level] = gsl_ring_prepend (sched->cycles[leaf_level], cycle_nodes);
+  sched->n_items++;
+}
+
+void
+_engine_schedule_restart (EngineSchedule *sched)
+{
+  g_return_if_fail (sched != NULL);
+  g_return_if_fail (sched->secured == TRUE);
+  g_return_if_fail (sched->cur_leaf_level == sched->leaf_levels);
+  g_return_if_fail (sched->cur_node == NULL);
+  g_return_if_fail (sched->cur_cycle == NULL);
+  
+  sched->cur_leaf_level = 0;
+  if (sched->leaf_levels > 0)
+    {
+      sched->cur_node = sched->nodes[0];
+      sched->cur_cycle = sched->cycles[0];
+    }
+}
+
+void
+_engine_schedule_secure (EngineSchedule *sched)
+{
+  g_return_if_fail (sched != NULL);
+  g_return_if_fail (sched->secured == FALSE);
+  
+  sched->secured = TRUE;
+  sched->cur_leaf_level = sched->leaf_levels;
+  
+  if (gsl_debug_check (GSL_MSG_SCHED))
+    _engine_schedule_debug_dump (sched);
+}
+
+static void
+schedule_advance (EngineSchedule *sched)
+{
+  while (!sched->cur_node && !sched->cur_cycle && sched->cur_leaf_level < sched->leaf_levels)
+    {
+      sched->cur_leaf_level += 1;
+      if (sched->cur_leaf_level < sched->leaf_levels)
+	{
+	  sched->cur_node = sched->nodes[sched->cur_leaf_level];
+	  sched->cur_cycle = sched->cycles[sched->cur_leaf_level];
+	}
+    }
+}
+
+EngineNode*
+_engine_schedule_pop_node (EngineSchedule *sched)
+{
+  g_return_val_if_fail (sched != NULL, NULL);
+  g_return_val_if_fail (sched->secured == TRUE, NULL);
+  g_return_val_if_fail (sched->cur_leaf_level <= sched->leaf_levels, NULL);
+  
+  do
+    {
+      guint leaf_level = sched->cur_leaf_level;
+      
+      if (sched->cur_node)
+	{
+	  EngineNode *node = sched->cur_node->data;
+	  
+	  sched->cur_node = gsl_ring_walk (sched->nodes[leaf_level], sched->cur_node);
+	  return node;
+	}
+      schedule_advance (sched);
+    }
+  while (sched->cur_node);
+  
+  /* nothing to hand out, either we're empty or still have cycles pending */
+  return NULL;
+}
+
+GslRing*
+_engine_schedule_pop_cycle (EngineSchedule *sched)
+{
+  g_return_val_if_fail (sched != NULL, NULL);
+  g_return_val_if_fail (sched->secured == TRUE, NULL);
+  g_return_val_if_fail (sched->cur_leaf_level <= sched->leaf_levels, NULL);
+  
+  do
+    {
+      guint leaf_level = sched->cur_leaf_level;
+      
+      if (sched->cur_cycle)
+	{
+	  GslRing *cycle = sched->cur_cycle->data;
+	  
+	  sched->cur_cycle = gsl_ring_walk (sched->cycles[leaf_level], sched->cur_cycle);
+	  return cycle;
+	}
+      schedule_advance (sched);
+    }
+  while (sched->cur_cycle);
+  
+  /* nothing to hand out, either we're empty or still have nodes pending */
+  return NULL;
+}
+
+void
+_engine_schedule_unsecure (EngineSchedule *sched)
+{
+  g_return_if_fail (sched != NULL);
+  g_return_if_fail (sched->secured == TRUE);
+  g_return_if_fail (sched->in_pqueue == FALSE);
+  g_return_if_fail (sched->cur_leaf_level == sched->leaf_levels);
+  g_return_if_fail (sched->cur_node == NULL);
+  g_return_if_fail (sched->cur_cycle == NULL);
+  
+  sched->secured = FALSE;
+  sched->cur_leaf_level = ~0;
+}
+
+
+/* --- depth scheduling --- */
+static GslRing*
+merge_untagged_node_lists_uniq (GslRing *ring1,
+				GslRing *ring2)
+{
+  GslRing *walk;
+  
+  /* paranoid, ensure all nodes are untagged */
+  for (walk = ring2; walk; walk = gsl_ring_walk (ring2, walk))
+    {
+      EngineNode *node = walk->data;
+      
+      g_assert (node->sched_router_tag == FALSE);
+    }
+  
+  /* tag all nodes in list first */
+  for (walk = ring1; walk; walk = gsl_ring_walk (ring1, walk))
+    {
+      EngineNode *node = walk->data;
+      
+      g_assert (node->sched_router_tag == FALSE);	/* paranoid check */
+      node->sched_router_tag = TRUE;
+    }
+  
+  /* merge list with missing (untagged) nodes */
+  for (walk = ring2; walk; walk = gsl_ring_walk (ring2, walk))
+    {
+      EngineNode *node = walk->data;
+      
+      if (node->sched_router_tag == FALSE)
+	ring1 = gsl_ring_append (ring1, node);
+    }
+  
+  /* untag all nodes */
+  for (walk = ring1; walk; walk = gsl_ring_walk (ring1, walk))
+    {
+      EngineNode *node = walk->data;
+      
+      node->sched_router_tag = FALSE;
+    }
+  for (walk = ring2; walk; walk = gsl_ring_walk (ring2, walk))
+    {
+      EngineNode *node = walk->data;
+      
+      node->sched_router_tag = FALSE;
+    }
+  gsl_ring_free (ring2);
+  return ring1;
+}
+
+static gboolean
+resolve_cycle (EngineCycle *cycle,
+	       EngineNode  *node,
+	       GslRing    **cycle_nodes_p)
+{
+  if (node != cycle->last)
+    return FALSE;
+  if (!cycle->seen_deferred_node)
+    {
+      g_error ("cycle without delay module: (%p)", cycle);
+    }
+  *cycle_nodes_p = merge_untagged_node_lists_uniq (*cycle_nodes_p, cycle->nodes);
+  cycle->nodes = NULL;
+  cycle->last = NULL;
+  return TRUE;
+}
+
+static gboolean
+master_resolve_cycles (EngineQuery *query,
+		       EngineNode  *node)
+{
+  GslRing *walk;
+  gboolean all_resolved = TRUE;
+  
+  g_assert (query->cycles != NULL);	/* paranoid */
+  
+  walk = query->cycles;
+  while (walk)
+    {
+      GslRing *next = gsl_ring_walk (query->cycles, walk);
+      EngineCycle *cycle = walk->data;
+      
+      if (resolve_cycle (cycle, node, &query->cycle_nodes))
+	{
+	  g_assert (cycle->last == NULL);	/* paranoid */
+	  g_assert (cycle->nodes == NULL);	/* paranoid */
+	  
+	  gsl_delete_struct (EngineCycle, cycle);
+	  query->cycles = gsl_ring_remove_node (query->cycles, walk);
+	}
+      else
+	all_resolved = FALSE;
+      walk = next;
+    }
+  if (all_resolved)
+    g_assert (query->cycles == NULL);	/* paranoid */
+  return all_resolved;
+}
+
+static void
+query_add_cycle (EngineQuery *query,
+		 EngineNode  *dep,
+		 EngineNode  *node)
+{
+  EngineCycle *cycle = gsl_new_struct0 (EngineCycle, 1);
+  
+  cycle->last = dep;
+  cycle->nodes = gsl_ring_prepend (NULL, node);
+  cycle->seen_deferred_node = ENGINE_NODE_IS_DEFERRED (node); /* dep will be checked when added to nodes */
+  query->cycles = gsl_ring_append (query->cycles, cycle);
+}
+
+static void
+query_merge_cycles (EngineQuery *query,
+		    EngineQuery *child_query,
+		    EngineNode  *node)
+{
+  GslRing *walk;
+  
+  g_assert (child_query->cycles != NULL);	/* paranoid */
+  
+  /* add node to all child cycles */
+  for (walk = child_query->cycles; walk; walk = gsl_ring_walk (child_query->cycles, walk))
+    {
+      EngineCycle *cycle = walk->data;
+      
+      cycle->nodes = gsl_ring_prepend (cycle->nodes, node);
+      cycle->seen_deferred_node |= ENGINE_NODE_IS_DEFERRED (node);
+    }
+  
+  /* merge child cycles into ours */
+  query->cycles = gsl_ring_concat (query->cycles, child_query->cycles);
+  child_query->cycles = NULL;
+  
+  /* merge childs cycle nodes from resolved cycles into ours */
+  query->cycle_nodes = merge_untagged_node_lists_uniq (query->cycle_nodes, child_query->cycle_nodes);
+  child_query->cycle_nodes = NULL;
+}
+
+static void
+subschedule_query_node (EngineSchedule *schedule,
+			EngineNode     *node,
+			EngineQuery    *query)
+{
+  guint i, j, leaf_level = 0;
+  
+  g_return_if_fail (node->sched_router_tag == FALSE);
+  
+  SCHED_DEBUG ("start_query(%p)", node);
+  node->sched_router_tag = TRUE;
+  for (i = 0; i < ENGINE_NODE_N_ISTREAMS (node); i++)
+    {
+      EngineNode *child = node->inputs[i].src_node;
+      
+      if (!child)
+	continue;
+      else if (ENGINE_NODE_IS_SCHEDULED (child))
+	{
+	  leaf_level = MAX (leaf_level, child->sched_leaf_level + 1);
+	  continue;
+	}
+      else if (child->sched_router_tag)	/* cycle */
+	{
+	  query_add_cycle (query, child, node);
+	}
+      else			/* nice boy ;) */
+	{
+	  EngineQuery child_query = { 0, };
+	  
+	  subschedule_query_node (schedule, child, &child_query);
+	  leaf_level = MAX (leaf_level, child_query.leaf_level + 1);
+	  if (!child_query.cycles)
+	    {
+	      g_assert (child_query.cycle_nodes == NULL);	/* paranoid */
+	      _engine_schedule_node (schedule, child, child_query.leaf_level);
+	    }
+	  else if (master_resolve_cycles (&child_query, child))
+	    {
+	      g_assert (child == child_query.cycle_nodes->data);	/* paranoid */
+	      _engine_schedule_cycle (schedule, child_query.cycle_nodes, child_query.leaf_level);
+	      child_query.cycle_nodes = NULL;
+	    }
+	  else
+	    query_merge_cycles (query, &child_query, node);
+	  g_assert (child_query.cycles == NULL);	/* paranoid */
+	  g_assert (child_query.cycle_nodes == NULL);	/* paranoid */
+	}
+    }
+  for (j = 0; j < ENGINE_NODE_N_JSTREAMS (node); j++)
+    for (i = 0; i < node->module.jstreams[j].n_connections; i++)
+      {
+	EngineNode *child = node->jinputs[j][i].src_node;
+	
+	if (ENGINE_NODE_IS_SCHEDULED (child))
+	  {
+	    leaf_level = MAX (leaf_level, child->sched_leaf_level + 1);
+	    continue;
+	  }
+	else if (child->sched_router_tag)	/* cycle */
+	  {
+	    query_add_cycle (query, child, node);
+	  }
+	else			/* nice boy ;) */
+	  {
+	    EngineQuery child_query = { 0, };
+	    
+	    subschedule_query_node (schedule, child, &child_query);
+	    leaf_level = MAX (leaf_level, child_query.leaf_level + 1);
+	    if (!child_query.cycles)
+	      {
+		g_assert (child_query.cycle_nodes == NULL);	/* paranoid */
+		_engine_schedule_node (schedule, child, child_query.leaf_level);
+	      }
+	    else if (master_resolve_cycles (&child_query, child))
+	      {
+		g_assert (child == child_query.cycle_nodes->data);	/* paranoid */
+		_engine_schedule_cycle (schedule, child_query.cycle_nodes, child_query.leaf_level);
+		child_query.cycle_nodes = NULL;
+	      }
+	    else
+	      query_merge_cycles (query, &child_query, node);
+	    g_assert (child_query.cycles == NULL);	/* paranoid */
+	    g_assert (child_query.cycle_nodes == NULL);	/* paranoid */
+	  }
+      }
+  query->leaf_level = leaf_level;
+  node->counter = GSL_TICK_STAMP;
+  node->sched_router_tag = FALSE;
+  SCHED_DEBUG ("end_query(%p)", node);
+}
+
+void
+_engine_schedule_consumer_node (EngineSchedule *schedule,
+				EngineNode     *node)
+{
+  EngineQuery query = { 0, };
+  
+  g_return_if_fail (schedule != NULL);
+  g_return_if_fail (schedule->secured == FALSE);
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (ENGINE_NODE_IS_CONSUMER (node));
+  
+  subschedule_query_node (schedule, node, &query);
+  g_assert (query.cycles == NULL);	/* paranoid */
+  g_assert (query.cycle_nodes == NULL);	/* paranoid */
+  _engine_schedule_node (schedule, node, query.leaf_level);
+}
diff --git a/flow/gsl/gslopschedule.h b/flow/gsl/gslopschedule.h
new file mode 100644
index 0000000..a2b5281
--- /dev/null
+++ b/flow/gsl/gslopschedule.h
@@ -0,0 +1,79 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_ENGINE_SCHEDULE_H__
+#define __GSL_ENGINE_SCHEDULE_H__
+
+#include <gsl/gslopnode.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+typedef struct
+{
+  EngineNode *last;	/* resolve node */
+  GslRing    *nodes;	/* of type EngineNode* */
+  guint       seen_deferred_node : 1;
+} EngineCycle;
+typedef struct
+{
+  guint    leaf_level;
+  GslRing *cycles;	/* of type Cycle* */
+  GslRing *cycle_nodes;	/* of type EngineNode* */
+} EngineQuery;
+struct _EngineSchedule
+{
+  guint     n_items;
+  guint     leaf_levels;
+  GslRing **nodes;	/* EngineNode* */
+  GslRing **cycles;	/* GslRing* */
+  guint	    secured : 1;
+  guint	    in_pqueue : 1;
+  guint	    cur_leaf_level;
+  GslRing  *cur_node;
+  GslRing  *cur_cycle;
+};
+#define	GSL_SCHEDULE_NONPOPABLE(schedule)		((schedule)->cur_leaf_level >= (schedule)->leaf_levels)
+
+
+/* --- MasterThread --- */
+EngineSchedule*	_engine_schedule_new		(void);
+void		_engine_schedule_clear		(EngineSchedule	*schedule);
+void		_engine_schedule_destroy	(EngineSchedule	*schedule);
+void		_engine_schedule_consumer_node	(EngineSchedule	*schedule,
+						 EngineNode	*node);
+void		_engine_schedule_node		(EngineSchedule	*schedule,
+						 EngineNode	*node,
+						 guint		 leaf_level);
+void		_engine_schedule_cycle		(EngineSchedule	*schedule,
+						 GslRing	*cycle_nodes,
+						 guint		 leaf_level);
+void		_engine_schedule_secure		(EngineSchedule	*schedule);
+EngineNode*	_engine_schedule_pop_node	(EngineSchedule	*schedule);
+GslRing*	_engine_schedule_pop_cycle	(EngineSchedule	*schedule);
+void		_engine_schedule_restart	(EngineSchedule	*schedule);
+void		_engine_schedule_unsecure	(EngineSchedule	*schedule);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_ENGINE_SCHEDULE_H__ */
diff --git a/flow/gsl/gsloputil.c b/flow/gsl/gsloputil.c
new file mode 100644
index 0000000..9adce89
--- /dev/null
+++ b/flow/gsl/gsloputil.c
@@ -0,0 +1,721 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsloputil.h"
+
+#include "gslcommon.h"
+#include "gslopnode.h"
+#include "gslopschedule.h"
+#include "gslsignal.h"
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <math.h>
+
+
+/* --- UserThread --- */
+GslOStream*
+_engine_alloc_ostreams (guint n)
+{
+  if (n)
+    {
+      guint i = sizeof (GslOStream) * n + sizeof (gfloat) * gsl_engine_block_size () * n;
+      GslOStream *streams = gsl_alloc_memblock0 (i);
+      gfloat *buffers = (gfloat*) (streams + n);
+
+      for (i = 0; i < n; i++)
+	{
+	  streams[i].values = buffers;
+	  buffers += gsl_engine_block_size ();
+	}
+      return streams;
+    }
+  else
+    return NULL;
+}
+
+static void
+free_node (EngineNode *node)
+{
+  guint j;
+
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (node->output_nodes == NULL);
+  g_return_if_fail (node->integrated == FALSE);
+  g_return_if_fail (node->sched_tag == FALSE);
+  g_return_if_fail (node->sched_router_tag == FALSE);
+  
+  if (node->module.klass->free)
+    node->module.klass->free (node->module.user_data, node->module.klass);
+  gsl_rec_mutex_destroy (&node->rec_mutex);
+  if (node->module.ostreams)
+    {
+      guint n = ENGINE_NODE_N_OSTREAMS (node);
+      guint i = sizeof (GslOStream) * n + sizeof (gfloat) * gsl_engine_block_size () * n;
+
+      gsl_free_memblock (i, node->module.ostreams);
+      gsl_delete_structs (EngineOutput, ENGINE_NODE_N_OSTREAMS (node), node->outputs);
+    }
+  if (node->module.istreams)
+    {
+      gsl_delete_structs (GslIStream, ENGINE_NODE_N_ISTREAMS (node), node->module.istreams);
+      gsl_delete_structs (EngineInput, ENGINE_NODE_N_ISTREAMS (node), node->inputs);
+    }
+  for (j = 0; j < ENGINE_NODE_N_JSTREAMS (node); j++)
+    {
+      g_free (node->jinputs[j]);
+      g_free (node->module.jstreams[j].values);
+    }
+  if (node->module.jstreams)
+    {
+      gsl_delete_structs (GslJStream, ENGINE_NODE_N_JSTREAMS (node), node->module.jstreams);
+      gsl_delete_structs (EngineJInput*, ENGINE_NODE_N_JSTREAMS (node), node->jinputs);
+    }
+  gsl_delete_struct (EngineNode, node);
+}
+
+static void
+free_job (GslJob *job)
+{
+  g_return_if_fail (job != NULL);
+  
+  switch (job->job_id)
+    {
+    case ENGINE_JOB_ACCESS:
+      if (job->data.access.free_func)
+	job->data.access.free_func (job->data.access.data);
+      break;
+    case ENGINE_JOB_DEBUG:
+      g_free (job->data.debug);
+      break;
+    case ENGINE_JOB_ADD_POLL:
+    case ENGINE_JOB_REMOVE_POLL:
+      g_free (job->data.poll.fds);
+      if (job->data.poll.free_func)
+	job->data.poll.free_func (job->data.poll.data);
+      break;
+    case ENGINE_JOB_DISCARD:
+      free_node (job->data.node);
+      break;
+    default: ;
+    }
+  gsl_delete_struct (GslJob, job);
+}
+
+static void
+free_flow_job (EngineFlowJob *fjob)
+{
+  switch (fjob->fjob_id)
+    {
+    case ENGINE_FLOW_JOB_SUSPEND:
+    case ENGINE_FLOW_JOB_RESUME:
+      gsl_delete_struct (EngineFlowJobAny, &fjob->any);
+      break;
+    case ENGINE_FLOW_JOB_ACCESS:
+      if (fjob->access.free_func)
+	fjob->access.free_func (fjob->access.data);
+      gsl_delete_struct (EngineFlowJobAccess, &fjob->access);
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+void
+_engine_free_trans (GslTrans *trans)
+{
+  GslJob *job;
+  
+  g_return_if_fail (trans != NULL);
+  g_return_if_fail (trans->comitted == FALSE);
+  if (trans->jobs_tail)
+    g_return_if_fail (trans->jobs_tail->next == NULL);	/* paranoid */
+  
+  job = trans->jobs_head;
+  while (job)
+    {
+      GslJob *tmp = job->next;
+      
+      free_job (job);
+      job = tmp;
+    }
+  gsl_delete_struct (GslTrans, trans);
+}
+
+
+/* -- master node list --- */
+static EngineNode      *master_node_list_head = NULL;
+static EngineNode      *master_node_list_tail = NULL;
+
+EngineNode*
+_engine_mnl_head (void)
+{
+  return master_node_list_head;
+}
+
+void
+_engine_mnl_remove (EngineNode *node)
+{
+  g_return_if_fail (node->integrated == TRUE);
+
+  node->integrated = FALSE;
+  /* remove */
+  if (node->mnl_prev)
+    node->mnl_prev->mnl_next = node->mnl_next;
+  else
+    master_node_list_head = node->mnl_next;
+  if (node->mnl_next)
+    node->mnl_next->mnl_prev = node->mnl_prev;
+  else
+    master_node_list_tail = node->mnl_prev;
+  node->mnl_prev = NULL;
+  node->mnl_next = NULL;
+}
+
+void
+_engine_mnl_integrate (EngineNode *node)
+{
+  g_return_if_fail (node->integrated == FALSE);
+  g_return_if_fail (node->flow_jobs == NULL);
+
+  node->integrated = TRUE;
+  /* append */
+  if (master_node_list_tail)
+    master_node_list_tail->mnl_next = node;
+  node->mnl_prev = master_node_list_tail;
+  master_node_list_tail = node;
+  if (!master_node_list_head)
+    master_node_list_head = master_node_list_tail;
+  g_assert (node->mnl_next == NULL);
+}
+
+void
+_engine_mnl_reorder (EngineNode *node)
+{
+  EngineNode *sibling;
+
+  g_return_if_fail (node->integrated == TRUE);
+
+  /* the master node list is partially sorted. that is, all
+   * nodes which are not scheduled and have pending flow_jobs
+   * are agglomerated at the head.
+   */
+  sibling = node->mnl_prev ? node->mnl_prev : node->mnl_next;
+  if (sibling && GSL_MNL_HEAD_NODE (node) != GSL_MNL_HEAD_NODE (sibling))
+    {
+      /* remove */
+      if (node->mnl_prev)
+	node->mnl_prev->mnl_next = node->mnl_next;
+      else
+	master_node_list_head = node->mnl_next;
+      if (node->mnl_next)
+	node->mnl_next->mnl_prev = node->mnl_prev;
+      else
+	master_node_list_tail = node->mnl_prev;
+      if (GSL_MNL_HEAD_NODE (node))	/* move towards head */
+	{
+	  /* prepend to non-NULL list */
+	  master_node_list_head->mnl_prev = node;
+	  node->mnl_next = master_node_list_head;
+	  master_node_list_head = node;
+	  node->mnl_prev = NULL;
+	}
+      else				/* move towards tail */
+	{
+	  /* append to non-NULL list */
+	  master_node_list_tail->mnl_next = node;
+	  node->mnl_prev = master_node_list_tail;
+	  master_node_list_tail = node;
+	  node->mnl_next = NULL;
+	}
+    }
+}
+
+
+/* --- const value blocks --- */
+typedef struct
+{
+  guint    n_nodes;
+  gfloat **nodes;
+  guint8  *nodes_used;
+} ConstValuesArray;
+
+static const guint8 CONST_VALUES_EXPIRE = 16;           /* expire value after being unused for 16 times */
+
+static inline gfloat**
+const_values_lookup_nextmost (ConstValuesArray *array,
+		              gfloat	        key_value)
+{
+  guint n_nodes = array->n_nodes;
+  
+  if (n_nodes > 0)
+    {
+      gfloat **nodes = array->nodes;
+      gfloat **check;
+      
+      nodes -= 1;
+      do
+	{
+	  guint i;
+	  register gfloat cmp;
+	  
+	  i = (n_nodes + 1) >> 1;
+	  check = nodes + i;
+	  cmp = key_value - **check;
+	  if (cmp > GSL_SIGNAL_EPSILON)
+	    {
+	      n_nodes -= i;
+	      nodes = check;
+	    }
+	  else if (cmp < -GSL_SIGNAL_EPSILON)
+	    n_nodes = i - 1;
+	  else /* cmp ~==~ 0.0 */
+	    return check;   /* matched */
+	}
+      while (n_nodes);
+
+      return check;  /* nextmost */
+    }
+  
+  return NULL;
+}
+
+static inline guint
+upper_power2 (guint number)
+{
+  return gsl_alloc_upper_power2 (MAX (number, 8));
+}
+
+static inline void
+const_values_insert (ConstValuesArray *array,
+		     guint             index,
+		     gfloat	      *value_block)
+{
+  if (array->n_nodes == 0)
+    {
+      guint new_size = upper_power2 (sizeof (gfloat*));
+      
+      array->nodes = g_realloc (array->nodes, new_size);
+      array->nodes_used = g_realloc (array->nodes_used, new_size / sizeof (gfloat*));
+      array->n_nodes = 1;
+
+      g_assert (index == 0);
+    }
+  else
+    {
+      guint n_nodes = array->n_nodes++;
+
+      if (*array->nodes[index] < *value_block)
+	index++;
+      
+      if (1)
+	{
+	  guint new_size = upper_power2 (array->n_nodes * sizeof (gfloat*));
+	  guint old_size = upper_power2 (n_nodes * sizeof (gfloat*));
+	  
+	  if (new_size != old_size)
+	    {
+	      array->nodes = g_realloc (array->nodes, new_size);
+	      array->nodes_used = g_realloc (array->nodes_used, new_size / sizeof(gfloat*));
+	    }
+	}
+      g_memmove (array->nodes + index + 1, array->nodes + index, (n_nodes - index) * sizeof (array->nodes[0]));
+      g_memmove (array->nodes_used + index + 1, array->nodes_used + index, (n_nodes - index) * sizeof (array->nodes_used[0]));
+    }
+
+  array->nodes[index] = value_block;
+  array->nodes_used[index] = CONST_VALUES_EXPIRE;
+}
+
+static ConstValuesArray cvalue_array = { 0, NULL, NULL };
+
+gfloat*
+gsl_engine_const_values (gfloat value)
+{
+  extern const gfloat gsl_engine_master_zero_block[];
+  gfloat **block;
+  
+  if (fabs (value) < GSL_SIGNAL_EPSILON)
+    return (gfloat*) gsl_engine_master_zero_block;
+
+  block = const_values_lookup_nextmost (&cvalue_array, value);
+
+  /* found correct match? */
+  if (block && fabs (**block - value) < GSL_SIGNAL_EPSILON)
+    {
+      cvalue_array.nodes_used[block - cvalue_array.nodes] = CONST_VALUES_EXPIRE;
+      return *block;
+    }
+  else
+    {
+      /* create new value block */
+      gfloat *values = g_new (gfloat, gsl_engine_block_size ());
+      guint i;
+
+      for (i = 0; i < gsl_engine_block_size (); i++)
+	values[i] = value;
+     
+      if (block)
+	const_values_insert (&cvalue_array, block - cvalue_array.nodes, values);
+      else
+	const_values_insert (&cvalue_array, 0, values);
+
+      return values;
+    }
+}
+
+void
+_engine_recycle_const_values (void)
+{
+  gfloat **nodes = cvalue_array.nodes;
+  guint8 *used = cvalue_array.nodes_used;
+  guint count = cvalue_array.n_nodes, e = 0, i;
+  
+  for (i = 0; i < count; i++)
+    {
+      used[i]--;  /* invariant: use counts are never 0 */
+      
+      if (used[i] == 0)
+	g_free (nodes[i]);
+      else /* preserve node */
+	{
+	  if (e < i)
+	    {
+	      nodes[e] = nodes[i];
+	      used[e] = used[i];
+	    }
+	  e++;
+	}
+    }
+  cvalue_array.n_nodes = e;
+}
+
+/* --- job transactions --- */
+static GslMutex       cqueue_trans = { 0, };
+static GslTrans      *cqueue_trans_pending_head = NULL;
+static GslTrans      *cqueue_trans_pending_tail = NULL;
+static GslCond        cqueue_trans_cond = { 0, };
+static GslTrans      *cqueue_trans_trash = NULL;
+static GslTrans      *cqueue_trans_active_head = NULL;
+static GslTrans      *cqueue_trans_active_tail = NULL;
+static EngineFlowJob *cqueue_trash_fjobs = NULL;
+static GslJob        *cqueue_trans_job = NULL;
+
+void
+_engine_enqueue_trans (GslTrans *trans)
+{
+  g_return_if_fail (trans != NULL);
+  g_return_if_fail (trans->comitted == TRUE);
+  g_return_if_fail (trans->jobs_head != NULL);
+  g_return_if_fail (trans->cqt_next == NULL);
+  
+  GSL_SPIN_LOCK (&cqueue_trans);
+  if (cqueue_trans_pending_tail)
+    {
+      cqueue_trans_pending_tail->cqt_next = trans;
+      cqueue_trans_pending_tail->jobs_tail->next = trans->jobs_head;
+    }
+  else
+    cqueue_trans_pending_head = trans;
+  cqueue_trans_pending_tail = trans;
+  GSL_SPIN_UNLOCK (&cqueue_trans);
+  gsl_cond_signal (&cqueue_trans_cond);
+}
+
+void
+_engine_wait_on_trans (void)
+{
+  GSL_SPIN_LOCK (&cqueue_trans);
+  while (cqueue_trans_pending_head || cqueue_trans_active_head)
+    gsl_cond_wait (&cqueue_trans_cond, &cqueue_trans);
+  GSL_SPIN_UNLOCK (&cqueue_trans);
+}
+
+gboolean
+_engine_job_pending (void)
+{
+  gboolean pending = cqueue_trans_job != NULL;
+  
+  if (!pending)
+    {
+      GSL_SPIN_LOCK (&cqueue_trans);
+      pending = cqueue_trans_pending_head != NULL;
+      GSL_SPIN_UNLOCK (&cqueue_trans);
+    }
+  return pending;
+}
+
+GslJob*
+_engine_pop_job (void)	/* (glong max_useconds) */
+{
+  /* clean up if necessary and try fetching new jobs */
+  if (!cqueue_trans_job)
+    {
+      if (cqueue_trans_active_head)
+	{
+	  GSL_SPIN_LOCK (&cqueue_trans);
+	  /* get rid of processed transaction and
+	   * signal UserThread which might be in
+	   * op_com_wait_on_trans()
+	   */
+	  cqueue_trans_active_tail->cqt_next = cqueue_trans_trash;
+	  cqueue_trans_trash = cqueue_trans_active_head;
+	  /* fetch new transaction */
+	  cqueue_trans_active_head = cqueue_trans_pending_head;
+	  cqueue_trans_active_tail = cqueue_trans_pending_tail;
+	  cqueue_trans_pending_head = NULL;
+	  cqueue_trans_pending_tail = NULL;
+	  GSL_SPIN_UNLOCK (&cqueue_trans);
+	  gsl_cond_signal (&cqueue_trans_cond);
+	}
+      else
+	{
+	  GSL_SPIN_LOCK (&cqueue_trans);
+	  /* fetch new transaction */
+	  cqueue_trans_active_head = cqueue_trans_pending_head;
+	  cqueue_trans_active_tail = cqueue_trans_pending_tail;
+	  cqueue_trans_pending_head = NULL;
+	  cqueue_trans_pending_tail = NULL;
+	  GSL_SPIN_UNLOCK (&cqueue_trans);
+	}
+      cqueue_trans_job = cqueue_trans_active_head ? cqueue_trans_active_head->jobs_head : NULL;
+    }
+  
+  /* pick new job and out of here */
+  if (cqueue_trans_job)
+    {
+      GslJob *job = cqueue_trans_job;
+      
+      cqueue_trans_job = job->next;
+      return job;
+    }
+  
+#if 0
+  /* wait until jobs are present */
+  if (max_useconds != 0)
+    {
+      GSL_SPIN_LOCK (&cqueue_trans);
+      if (!cqueue_trans_pending_head)
+	gsl_cond_wait_timed (&cqueue_trans_cond,
+			     &cqueue_trans,
+			     max_useconds);
+      GSL_SPIN_UNLOCK (&cqueue_trans);
+      
+      /* there may be jobs now, start from scratch */
+      return op_com_pop_job_timed (max_useconds < 0 ? -1 : 0);
+    }
+#endif
+  
+  /* time expired, no jobs... */
+  return NULL;
+}
+
+
+/* --- user thread garbage collection --- */
+/**
+ * gsl_engine_garbage_collect
+ *
+ * GSL Engine user thread function. Collects processed jobs
+ * and transactions from the engine and frees them, this
+ * involves callback invocation of GslFreeFunc() functions,
+ * e.g. from gsl_job_access() or gsl_flow_job_access()
+ * jobs.
+ * This function may only be called from the user thread,
+ * as GslFreeFunc() functions are guranteed to be executed
+ * in the user thread.
+ */
+void
+gsl_engine_garbage_collect (void)
+{
+  GslTrans *trans;
+  EngineFlowJob *fjobs;
+
+  GSL_SPIN_LOCK (&cqueue_trans);
+  trans = cqueue_trans_trash;
+  cqueue_trans_trash = NULL;
+  fjobs = cqueue_trash_fjobs;
+  cqueue_trash_fjobs = NULL;
+  GSL_SPIN_UNLOCK (&cqueue_trans);
+
+  while (trans)
+    {
+      GslTrans *t = trans;
+
+      trans = t->cqt_next;
+      t->cqt_next = NULL;
+      t->jobs_tail->next = NULL;
+      t->comitted = FALSE;
+      _engine_free_trans (t);
+    }
+
+  while (fjobs)
+    {
+      EngineFlowJob *j = fjobs;
+
+      fjobs = j->any.next;
+      j->any.next = NULL;
+      free_flow_job (j);
+    }
+}
+
+
+/* --- node processing queue --- */
+static GslMutex          pqueue_mutex = { 0, };
+static EngineSchedule       *pqueue_schedule = NULL;
+static guint             pqueue_n_nodes = 0;
+static guint             pqueue_n_cycles = 0;
+static GslCond		 pqueue_done_cond = { 0, };
+static EngineFlowJob    *pqueue_trash_fjobs_first = NULL;
+static EngineFlowJob    *pqueue_trash_fjobs_last = NULL;
+
+void
+_engine_set_schedule (EngineSchedule *sched)
+{
+  g_return_if_fail (sched != NULL);
+  g_return_if_fail (sched->secured == TRUE);
+  
+  GSL_SPIN_LOCK (&pqueue_mutex);
+  if_reject (pqueue_schedule)
+    {
+      GSL_SPIN_UNLOCK (&pqueue_mutex);
+      g_warning (G_STRLOC ": schedule already set");
+      return;
+    }
+  pqueue_schedule = sched;
+  sched->in_pqueue = TRUE;
+  GSL_SPIN_UNLOCK (&pqueue_mutex);
+}
+
+void
+_engine_unset_schedule (EngineSchedule *sched)
+{
+  EngineFlowJob *trash_fjobs_first, *trash_fjobs_last;
+
+  g_return_if_fail (sched != NULL);
+  
+  GSL_SPIN_LOCK (&pqueue_mutex);
+  if_reject (pqueue_schedule != sched)
+    {
+      GSL_SPIN_UNLOCK (&pqueue_mutex);
+      g_warning (G_STRLOC ": schedule(%p) not currently set", sched);
+      return;
+    }
+  if_reject (pqueue_n_nodes || pqueue_n_cycles)
+    g_warning (G_STRLOC ": schedule(%p) still busy", sched);
+
+  sched->in_pqueue = FALSE;
+  pqueue_schedule = NULL;
+  trash_fjobs_first = pqueue_trash_fjobs_first;
+  trash_fjobs_last = pqueue_trash_fjobs_last;
+  pqueue_trash_fjobs_first = NULL;
+  pqueue_trash_fjobs_last = NULL;
+  GSL_SPIN_UNLOCK (&pqueue_mutex);
+
+  if (trash_fjobs_first)	/* move trash flow jobs */
+    {
+      GSL_SPIN_LOCK (&cqueue_trans);
+      trash_fjobs_last->any.next = cqueue_trash_fjobs;
+      cqueue_trash_fjobs = trash_fjobs_first;
+      GSL_SPIN_UNLOCK (&cqueue_trans);
+    }
+}
+
+EngineNode*
+_engine_pop_unprocessed_node (void)
+{
+  EngineNode *node;
+  
+  GSL_SPIN_LOCK (&pqueue_mutex);
+  node = pqueue_schedule ? _engine_schedule_pop_node (pqueue_schedule) : NULL;
+  if (node)
+    pqueue_n_nodes += 1;
+  GSL_SPIN_UNLOCK (&pqueue_mutex);
+  
+  if (node)
+    ENGINE_NODE_LOCK (node);
+  
+  return node;
+}
+
+void
+_engine_push_processed_node (EngineNode *node)
+{
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (pqueue_n_nodes > 0);
+  g_return_if_fail (ENGINE_NODE_IS_SCHEDULED (node));
+  
+  GSL_SPIN_LOCK (&pqueue_mutex);
+  g_assert (pqueue_n_nodes > 0);        /* paranoid */
+  if (node->fjob_first)	/* collect trash flow jobs */
+    {
+      node->fjob_last->any.next = pqueue_trash_fjobs_first;
+      pqueue_trash_fjobs_first = node->fjob_first;
+      if (!pqueue_trash_fjobs_last)
+	pqueue_trash_fjobs_last = node->fjob_last;
+      node->fjob_first = NULL;
+      node->fjob_last = NULL;
+    }
+  pqueue_n_nodes -= 1;
+  ENGINE_NODE_UNLOCK (node);
+  if (!pqueue_n_nodes && !pqueue_n_cycles && GSL_SCHEDULE_NONPOPABLE (pqueue_schedule))
+    gsl_cond_signal (&pqueue_done_cond);
+  GSL_SPIN_UNLOCK (&pqueue_mutex);
+}
+
+GslRing*
+_engine_pop_unprocessed_cycle (void)
+{
+  return NULL;
+}
+
+void
+_engine_push_processed_cycle (GslRing *cycle)
+{
+  g_return_if_fail (cycle != NULL);
+  g_return_if_fail (pqueue_n_cycles > 0);
+  g_return_if_fail (ENGINE_NODE_IS_SCHEDULED (cycle->data));
+}
+
+void
+_engine_wait_on_unprocessed (void)
+{
+  GSL_SPIN_LOCK (&pqueue_mutex);
+  while (pqueue_n_nodes || pqueue_n_cycles || !GSL_SCHEDULE_NONPOPABLE (pqueue_schedule))
+    gsl_cond_wait (&pqueue_done_cond, &pqueue_mutex);
+  GSL_SPIN_UNLOCK (&pqueue_mutex);
+}
+
+
+/* --- initialization --- */
+void
+_gsl_init_engine_utils (void)
+{
+  static gboolean initialized = FALSE;
+
+  g_assert (initialized == FALSE); /* single invocation */
+  initialized++;
+
+  gsl_mutex_init (&cqueue_trans);
+  gsl_cond_init (&cqueue_trans_cond);
+  gsl_mutex_init (&pqueue_mutex);
+  gsl_cond_init (&pqueue_done_cond);
+}
+
+
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gsloputil.h b/flow/gsl/gsloputil.h
new file mode 100644
index 0000000..9089770
--- /dev/null
+++ b/flow/gsl/gsloputil.h
@@ -0,0 +1,86 @@
+/* GSL Engine - Flow module operation engine
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_ENGINE_UTIL_H__
+#define __GSL_ENGINE_UTIL_H__
+
+#include <gsl/gsldefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- typedefs --- */
+typedef struct _EngineNode     EngineNode;
+typedef struct _EngineSchedule EngineSchedule;
+
+
+/* --- UserThread --- */
+void		_engine_free_trans		(GslTrans      *trans);
+GslOStream*	_engine_alloc_ostreams		(guint		n);
+#if 0	/* gslengine.h: */
+void            gsl_engine_garbage_collect	(void);
+gfloat*		gsl_engine_const_values		(gfloat		value);
+#endif
+
+
+/* --- MasterThread --- */
+void		_engine_recycle_const_values	(void);
+/* master node list */
+void		_engine_mnl_remove		(EngineNode	*node);
+void		_engine_mnl_reorder		(EngineNode	*node);
+void		_engine_mnl_integrate		(EngineNode	*node);
+#define	GSL_MNL_HEAD_NODE(node)			((node)->flow_jobs && !(node)->sched_tag)
+EngineNode*	_engine_mnl_head		(void);
+
+/* communication routines for threads:
+ * UserThread   - main application
+ * MasterThread - op engine control thread
+ * SlaveThread  - op engine calculation threads
+ *
+ * these functions are for _internal_ use of gslop*.c implementations
+ */
+
+/* --- job transactions --- */
+/* UserThread */
+void		_engine_enqueue_trans	(GslTrans	*trans);
+GslTrans*	_engine_collect_trans	(void);
+void		_engine_wait_on_trans	(void);
+/* MasterThread */
+/* GslJob*	_engine_pop_job_timed	(glong		 max_useconds); */
+GslJob*		_engine_pop_job		(void);
+gboolean	_engine_job_pending	(void);
+
+
+/* --- node processing queue --- */
+void	    _engine_set_schedule		(EngineSchedule	*schedule);
+void	    _engine_unset_schedule		(EngineSchedule	*schedule);
+EngineNode* _engine_pop_unprocessed_node	(void);
+void	    _engine_push_processed_node		(EngineNode	*node);
+GslRing*    _engine_pop_unprocessed_cycle	(void);
+void	    _engine_push_processed_cycle	(GslRing	*cycle);
+void	    _engine_wait_on_unprocessed		(void);
+
+       
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_ENGINE_UTIL_H__ */
diff --git a/flow/gsl/gsloscillator-aux.c b/flow/gsl/gsloscillator-aux.c
new file mode 100644
index 0000000..d755bc5
--- /dev/null
+++ b/flow/gsl/gsloscillator-aux.c
@@ -0,0 +1,214 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 1999, 2000-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#define	OSC_FLAGS		(GSL_INCLUDER_CASE | OSC_INCLUDER_FLAGS)
+#define ISYNC1_OSYNC0		((OSC_FLAGS & OSC_FLAG_ISYNC) && !(OSC_FLAGS & OSC_FLAG_OSYNC))
+#define ISYNC1_OSYNC1		((OSC_FLAGS & OSC_FLAG_ISYNC) && (OSC_FLAGS & OSC_FLAG_OSYNC))
+#define ISYNC0_OSYNC1		((OSC_FLAGS & OSC_FLAG_OSYNC) && !(OSC_FLAGS & OSC_FLAG_ISYNC))
+#define WITH_OSYNC		(OSC_FLAGS & OSC_FLAG_OSYNC)
+#define WITH_FREQ		(OSC_FLAGS & OSC_FLAG_FREQ)
+#define WITH_SMOD		(OSC_FLAGS & OSC_FLAG_SELF_MOD)
+#define WITH_LMOD		(OSC_FLAGS & OSC_FLAG_LINEAR_MOD)
+#define WITH_EMOD		(OSC_FLAGS & OSC_FLAG_EXP_MOD)
+#define WITH_PWM_MOD		(OSC_FLAGS & OSC_FLAG_PWM_MOD)
+#define PULSE_OSC		(OSC_FLAGS & OSC_FLAG_PULSE_OSC)
+
+
+static void
+GSL_INCLUDER_FUNC (GslOscData   *osc,
+		   guint         n_values,
+		   const gfloat *ifreq,
+		   const gfloat *mod_in,
+		   const gfloat *sync_in,
+		   const gfloat *pwm_in,
+		   gfloat       *mono_out,
+		   gfloat       *sync_out)
+{
+  gfloat last_sync_level = osc->last_sync_level;
+  gfloat last_pwm_level = osc->last_pwm_level;
+  gdouble last_freq_level = osc->last_freq_level;
+  guint32 cur_pos = osc->cur_pos;
+  guint32 last_pos = osc->last_pos;
+  guint32 sync_pos, pos_inc;
+  gfloat posm_strength, self_posm_strength;
+  gfloat *boundary = mono_out + n_values;
+  GslOscWave *wave = &osc->wave;
+  
+  /* FIXME: should we do gsl_fpu_setround() here? */
+  
+  pos_inc = gsl_dtoi (osc->last_freq_level * gsl_cent_factor (osc->config.fine_tune) * wave->freq_to_step);
+  sync_pos = osc->config.phase * wave->phase_to_pos;
+  posm_strength = pos_inc * osc->config.fm_strength;
+  self_posm_strength = pos_inc * osc->config.self_fm_strength;
+  
+  /* do the mixing */
+  do
+    {
+      gfloat v;
+      
+      /* handle syncs
+       */
+#if (ISYNC1_OSYNC0)		/* input sync only */
+      {
+	gfloat sync_level = *sync_in++;
+	if_reject (GSL_SIGNAL_RAISING_EDGE (last_sync_level, sync_level))
+	  cur_pos = sync_pos;
+	last_sync_level = sync_level;
+      }
+#elif (ISYNC1_OSYNC1)		/* input and output sync */
+      {
+	gfloat sync_level = *sync_in++;
+	if_reject (GSL_SIGNAL_RAISING_EDGE (last_sync_level, sync_level))
+	  {
+	    cur_pos = sync_pos;
+	    *sync_out++ = 1.0;
+	  }
+	else /* figure output sync position */
+	  {
+	    guint is_sync = (sync_pos <= cur_pos) + (last_pos < sync_pos) + (cur_pos < last_pos);
+	    *sync_out++ = is_sync >= 2 ? 1.0 : 0.0;
+	  }
+	last_sync_level = sync_level;
+      }
+#elif (ISYNC0_OSYNC1)		/* output sync only */
+      {
+	/* figure output sync position */
+	guint is_sync = (sync_pos <= cur_pos) + (last_pos < sync_pos) + (cur_pos < last_pos);
+	*sync_out++ = is_sync >= 2 ? 1.0 : 0.0;
+      }
+#endif
+      
+      /* track frequency changes
+       */
+#if (WITH_FREQ)
+      {
+	gdouble freq_level = *ifreq++;
+	freq_level = GSL_SIGNAL_TO_FREQ (freq_level);
+	if (GSL_SIGNAL_FREQ_CHANGED (last_freq_level, freq_level))
+	  {
+	    if_reject (freq_level <= wave->min_freq || freq_level > wave->max_freq)
+	      {
+		gdouble fcpos, flpos;
+		const gfloat *orig_values = wave->values;
+
+		fcpos = cur_pos * wave->ifrac_to_float;
+		flpos = last_pos * wave->ifrac_to_float;
+		gsl_osc_table_lookup (osc->config.table, freq_level, wave);
+		if (orig_values != wave->values)	/* catch non-changes */
+		  {
+		    last_pos = flpos / wave->ifrac_to_float;
+		    cur_pos = fcpos / wave->ifrac_to_float;
+		    sync_pos = osc->config.phase * wave->phase_to_pos;
+		    pos_inc = gsl_dtoi (freq_level * gsl_cent_factor (osc->config.fine_tune) * wave->freq_to_step);
+#if (PULSE_OSC)
+		    osc->last_pwm_level = 0;
+		    osc_update_pwm_offset (osc, osc->last_pwm_level);
+		    last_pwm_level = osc->last_pwm_level;
+#endif
+		  }
+	      }
+	    else
+	      pos_inc = gsl_dtoi (freq_level * gsl_cent_factor (osc->config.fine_tune) * wave->freq_to_step);
+	    posm_strength = pos_inc * osc->config.fm_strength;
+	    self_posm_strength = pos_inc * osc->config.self_fm_strength;
+	    last_freq_level = freq_level;
+	  }
+      }
+#endif
+
+      /* track pulse witdh modulation
+       */
+#if (WITH_PWM_MOD)
+      {
+	gfloat pwm_level = *pwm_in++;
+	if (fabs (last_pwm_level - pwm_level) > 1.0 / 65536.0)
+	  {
+	    last_pwm_level = pwm_level;
+	    osc_update_pwm_offset (osc, pwm_level);
+	  }
+      }
+#endif
+
+      /* output signal calculation
+       */
+#if (PULSE_OSC)		/* pulse width modulation oscillator */
+      {
+	guint32 tpos, ipos;
+	tpos = cur_pos >> wave->n_frac_bits;
+	ipos = (cur_pos - osc->pwm_offset) >> wave->n_frac_bits;
+	v = wave->values[tpos] - wave->values[ipos];
+	v = (v + osc->pwm_center) * osc->pwm_max;
+      }
+#else			/* table read out and linear ipol */
+      {
+	guint32 tpos, ifrac;
+	gfloat ffrac, w;
+	tpos = cur_pos >> wave->n_frac_bits;
+	ifrac = cur_pos & wave->frac_bitmask;
+	ffrac = ifrac * wave->ifrac_to_float;
+	v = wave->values[tpos];
+	w = wave->values[tpos + 1];
+	v *= 1.0 - ffrac;
+	w *= ffrac;
+	v += w;
+      }
+#endif	/* v = value_out done */
+      *mono_out++ = v;
+      
+      /* position increment
+       */
+#if (WITH_OSYNC)
+      last_pos = cur_pos;
+#endif
+#if (WITH_SMOD)			/* self modulation */
+      cur_pos += self_posm_strength * v;
+#endif
+#if (WITH_LMOD)			/* linear fm */
+      {
+	gfloat mod_level = *mod_in++;
+	cur_pos += pos_inc + posm_strength * mod_level;
+      }
+#elif (WITH_EMOD)		/* exponential fm */
+      {
+	gfloat mod_level = *mod_in++;
+	cur_pos += pos_inc * gsl_signal_exp2 (osc->config.fm_strength * mod_level);
+      }
+#else				/* no modulation */
+      cur_pos += pos_inc;
+#endif
+    }
+  while (mono_out < boundary);
+  
+  osc->last_pos = WITH_OSYNC ? last_pos : cur_pos;
+  osc->cur_pos = cur_pos;
+  osc->last_sync_level = last_sync_level;
+  osc->last_freq_level = last_freq_level;
+  osc->last_pwm_level = last_pwm_level;
+}
+
+#undef ISYNC1_OSYNC0
+#undef ISYNC1_OSYNC1
+#undef ISYNC0_OSYNC1
+#undef WITH_OSYNC
+#undef WITH_FREQ
+#undef WITH_SMOD
+#undef WITH_LMOD
+#undef WITH_EMOD
+#undef OSC_FLAGS
diff --git a/flow/gsl/gsloscillator.c b/flow/gsl/gsloscillator.c
new file mode 100644
index 0000000..0747cff
--- /dev/null
+++ b/flow/gsl/gsloscillator.c
@@ -0,0 +1,219 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 1999, 2000-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gsloscillator.h"
+
+#include "gslsignal.h"
+
+#define	SIGNAL_LEVEL_INVAL	(-2.0)	/* trigger level-changed checks */
+
+
+/* --- functions --- */
+static inline void
+osc_update_pwm_offset (GslOscData *osc,
+		       gfloat	   pulse_mod) /* -1..+1 */
+{
+  guint32 maxp_offs, minp_offs, mpos, tpos;
+  gfloat min, max, foffset;
+
+  /* figure actual pulse width (0..1) */
+  foffset = osc->config.pulse_width;	/* 0..1 */
+  foffset += pulse_mod * osc->config.pulse_mod_strength;
+  foffset = CLAMP (foffset, 0.0, 1.0);
+
+  /* calculate pulse scaling range for this offset */
+  osc->pwm_offset = foffset * osc->wave.n_values;
+  osc->pwm_offset <<= osc->wave.n_frac_bits;
+
+  maxp_offs = (osc->wave.min_pos + osc->wave.n_values + osc->wave.max_pos) << (osc->wave.n_frac_bits - 1);
+  minp_offs = (osc->wave.max_pos + osc->wave.min_pos) << (osc->wave.n_frac_bits - 1);
+  
+  mpos = maxp_offs + (osc->pwm_offset >> 1);
+  tpos = mpos >> osc->wave.n_frac_bits;
+  max = osc->wave.values[tpos];
+  mpos -= osc->pwm_offset;
+  tpos = mpos >> osc->wave.n_frac_bits;
+  max -= osc->wave.values[tpos];
+  mpos = minp_offs + (osc->pwm_offset >> 1);
+  tpos = mpos >> osc->wave.n_frac_bits;
+  min = osc->wave.values[tpos];
+  mpos -= osc->pwm_offset;
+  tpos = mpos >> osc->wave.n_frac_bits;
+  min -= osc->wave.values[tpos];
+  osc->pwm_center = (min + max) / -2.0;
+  min = fabs (min + osc->pwm_center);
+  max = fabs (max + osc->pwm_center);
+  max = MAX (max, min);
+  if_reject (max < GSL_FLOAT_MIN_NORMAL)
+    {
+      osc->pwm_center = foffset < 0.5 ? -1.0 : +1.0;
+      osc->pwm_max = 1.0;
+    }
+  else
+    osc->pwm_max = 1.0 / max;
+}
+
+
+/* --- generate processing function variants --- */
+#define OSC_FLAG_INVAL		(0xffffffff)
+#define OSC_FLAG_ISYNC		(1)
+#define OSC_FLAG_OSYNC		(2)
+#define OSC_FLAG_FREQ		(4)
+#define OSC_FLAG_SELF_MOD	(8)
+#define	OSC_FLAG_LINEAR_MOD	(16)
+#define	OSC_FLAG_EXP_MOD	(32)
+#define	OSC_FLAG_PWM_MOD	(64)
+#define	OSC_FLAG_PULSE_OSC	(128)
+
+/* normal oscillator variants */
+#define	OSC_INCLUDER_FLAGS	0
+#define	GSL_INCLUDER_FIRST_CASE	0
+#define	GSL_INCLUDER_LAST_CASE	63
+#define	GSL_INCLUDER_NAME	oscillator_process_normal
+#define	GSL_INCLUDER_TABLE	static void (*osc_process_table[]) (GslOscData*,guint, \
+                                const gfloat*,const gfloat*,const gfloat*, \
+		                const gfloat*,gfloat*,gfloat*)
+#define	GSL_INCLUDER_FILE	"gsloscillator-aux.c"
+#include "gslincluder.c"
+#undef	OSC_INCLUDER_FLAGS
+
+/* pulse width modulation oscillator variants */
+#define	OSC_INCLUDER_FLAGS	OSC_FLAG_PULSE_OSC
+#define	GSL_INCLUDER_FIRST_CASE	0
+#define	GSL_INCLUDER_LAST_CASE	127
+#define	GSL_INCLUDER_NAME	oscillator_process_pulse
+#define	GSL_INCLUDER_TABLE	static void (*osc_process_pulse_table[]) (GslOscData*,guint, \
+                                const gfloat*,const gfloat*,const gfloat*, \
+		                const gfloat*,gfloat*,gfloat*)
+#define	GSL_INCLUDER_FILE	"gsloscillator-aux.c"
+#include "gslincluder.c"
+#undef	OSC_INCLUDER_FLAGS
+
+
+/* --- functions --- */
+static inline void
+osc_process (GslOscData   *osc,
+	     guint         n_values,
+	     guint	   mode,
+	     const gfloat *ifreq,
+	     const gfloat *imod,
+	     const gfloat *isync,
+	     const gfloat *ipwm,
+	     gfloat       *mono_out,
+	     gfloat       *sync_out)
+{
+  mode |= isync ? OSC_FLAG_ISYNC : 0;
+  mode |= sync_out ? OSC_FLAG_OSYNC : 0;
+  mode |= ifreq ? OSC_FLAG_FREQ : 0;
+  if (osc->config.pulse_mod_strength > GSL_FLOAT_MIN_NORMAL)
+    mode |= ipwm ? OSC_FLAG_PWM_MOD : 0;
+  if (osc->config.self_fm_strength > GSL_FLOAT_MIN_NORMAL)
+    mode |= OSC_FLAG_SELF_MOD;
+  if (imod && osc->config.exponential_fm)
+    mode |= OSC_FLAG_EXP_MOD;
+  else if (imod)
+    mode |= OSC_FLAG_LINEAR_MOD;
+  
+  if_reject (mode != osc->last_mode)
+    {
+      guint change_mask = osc->last_mode >= OSC_FLAG_INVAL ? OSC_FLAG_INVAL : osc->last_mode ^ mode;
+      
+      if (change_mask & OSC_FLAG_FREQ)
+	{
+	  gdouble fcpos, flpos;
+
+	  fcpos = osc->cur_pos * osc->wave.ifrac_to_float;
+	  flpos = osc->last_pos * osc->wave.ifrac_to_float;
+	  osc->last_freq_level = osc->config.cfreq;
+	  gsl_osc_table_lookup (osc->config.table, osc->last_freq_level, &osc->wave);
+	  osc->last_pos = flpos / osc->wave.ifrac_to_float;
+	  osc->cur_pos = fcpos / osc->wave.ifrac_to_float;
+	}
+      if (!(mode & OSC_FLAG_ISYNC))
+	osc->last_sync_level = 0;
+      if (mode & OSC_FLAG_PULSE_OSC)
+	{
+	  osc->last_pwm_level = 0;
+	  osc_update_pwm_offset (osc, osc->last_pwm_level);
+	}
+      osc->last_mode = mode;
+    }
+  
+  /* invoke generated function variant */
+  if (mode & OSC_FLAG_PULSE_OSC)
+    osc_process_pulse_table[mode & ~OSC_FLAG_PULSE_OSC] (osc, n_values,
+							 ifreq, imod, isync, ipwm,
+							 mono_out, sync_out);
+  else
+    osc_process_table[mode] (osc, n_values,
+			     ifreq, imod, isync, NULL,
+			     mono_out, sync_out);
+}
+
+void
+gsl_osc_process (GslOscData   *osc,
+		 guint         n_values,
+		 const gfloat *ifreq,
+		 const gfloat *imod,
+		 const gfloat *isync,
+		 gfloat       *mono_out,
+		 gfloat       *sync_out)
+{
+  g_return_if_fail (osc != NULL);
+  g_return_if_fail (n_values > 0);
+  g_return_if_fail (mono_out != NULL);
+
+  if (osc->last_mode & OSC_FLAG_PULSE_OSC)
+    osc->last_mode = OSC_FLAG_INVAL;
+  osc_process (osc, n_values, 0,
+	       ifreq, imod, isync, NULL,
+	       mono_out, sync_out);
+}
+
+void
+gsl_osc_process_pulse (GslOscData   *osc,
+		       guint         n_values,
+		       const gfloat *ifreq,
+		       const gfloat *imod,
+		       const gfloat *isync,
+		       const gfloat *ipwm,
+		       gfloat       *mono_out,
+		       gfloat       *sync_out)
+{
+  g_return_if_fail (osc != NULL);
+  g_return_if_fail (n_values > 0);
+  g_return_if_fail (mono_out != NULL);
+
+  if (!(osc->last_mode & OSC_FLAG_PULSE_OSC))
+    osc->last_mode = OSC_FLAG_INVAL;
+  osc_process (osc, n_values, OSC_FLAG_PULSE_OSC,
+	       ifreq, imod, isync, ipwm,
+	       mono_out, sync_out);
+}
+
+void
+gsl_osc_config (GslOscData   *osc,
+		GslOscConfig *config)
+{
+  g_return_if_fail (osc != NULL);
+  g_return_if_fail (config != NULL);
+  g_return_if_fail (config->table != NULL);
+
+  osc->config = *config;
+  osc->last_mode = OSC_FLAG_INVAL;
+}
diff --git a/flow/gsl/gsloscillator.h b/flow/gsl/gsloscillator.h
new file mode 100644
index 0000000..24223fc
--- /dev/null
+++ b/flow/gsl/gsloscillator.h
@@ -0,0 +1,84 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 1999, 2000-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_OSCILLATOR_H__
+#define __GSL_OSCILLATOR_H__
+
+#include <gsl/gsldefs.h>
+#include <gsl/gslosctable.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- structures --- */
+typedef struct
+{
+  GslOscTable	*table;
+  guint		 exponential_fm : 1;
+  gfloat	 fm_strength;		/* linear: 0..1, exponential: n_octaves */
+  gfloat	 self_fm_strength;	/* 0..1 */
+  gfloat	 phase;			/* -0.5..+0.5 */
+  gfloat	 cfreq;			/* for ifreq == NULL */
+  gfloat	 pulse_width;		/* 0..1 */
+  gfloat	 pulse_mod_strength;	/* 0..0.5 */
+  gint		 fine_tune;		/* -100..+100 */
+} GslOscConfig;
+typedef struct
+{
+  GslOscConfig	 config;
+  guint		 last_mode;
+  guint32	 cur_pos, last_pos;
+  gfloat	 last_sync_level;
+  gdouble	 last_freq_level;
+  gfloat	 last_pwm_level;
+  GslOscWave	 wave;
+  /* pwm */
+  guint32	 pwm_offset;
+  gfloat	 pwm_max, pwm_center;
+} GslOscData;
+
+
+/* --- Oscillator --- */
+void	gsl_osc_config		(GslOscData	*osc,
+				 GslOscConfig	*config);
+void	gsl_osc_process		(GslOscData	*osc,
+				 guint		 n_values,
+				 const gfloat	*ifreq,
+				 const gfloat	*imod,
+				 const gfloat	*isync,
+				 gfloat		*mono_out,
+				 gfloat		*sync_out);
+void	gsl_osc_process_pulse	(GslOscData	*osc,
+				 guint		 n_values,
+				 const gfloat	*ifreq,
+				 const gfloat	*imod,
+				 const gfloat	*isync,
+				 const gfloat	*ipwm,
+				 gfloat		*mono_out,
+				 gfloat		*sync_out);
+
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_OSCILLATOR_H__ */
diff --git a/flow/gsl/gslosctable.c b/flow/gsl/gslosctable.c
new file mode 100644
index 0000000..f3e096d
--- /dev/null
+++ b/flow/gsl/gslosctable.c
@@ -0,0 +1,626 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslosctable.h"
+
+#include <string.h>
+#include "gbsearcharray.h"
+#include "gslcommon.h"
+#include "gslmath.h"
+#include "gslfft.h"
+
+
+#define OSC_DEBUG		GSL_DEBUG_FUNCTION (GSL_MSG_OSC, G_STRLOC)
+
+#define	OSC_FREQ_EPSILON	(1e-3)	/* range within which frequencies are "equal" */
+
+/* compare mfreqs against each other, use an arbitrary sample rate
+ * for which OSC_FREQ_EPSILON makes sense
+ */
+#define	CACHE_MATCH_FREQ(usr_mfreq, cache_mfreq) \
+  (fabs ((cache_mfreq) * 44107 - (usr_mfreq) * 44107) < OSC_FREQ_EPSILON)
+
+
+/* --- structures --- */
+typedef struct
+{
+  /* main key (osc and cache tables) */
+  gfloat         mfreq;			/* [0..0.5], mix_freq relative */
+  /* secondary key (cache tables) */
+  GslOscWaveForm wave_form;
+  guint8	*filter_func;		/* just here for key indexing */
+  /* data */
+  guint		 ref_count;
+  guint		 min_pos, max_pos;	/* pulse extension */
+  guint          n_values;
+  const gfloat   values[1];		/* flexible array */
+} OscTableEntry;
+
+
+/* --- prototypes --- */
+static gint	cache_table_entry_locs_cmp	(gconstpointer	bsearch_node1, /* key */
+						 gconstpointer	bsearch_node2);
+static gint	osc_table_entry_locs_cmp	(gconstpointer	bsearch_node1, /* key */
+						 gconstpointer	bsearch_node2);
+static void	osc_wave_extrema_pos		(guint		n_values,
+						 const gfloat *values,
+						 guint        *minp_p,
+						 guint        *maxp_p);
+void		gsl_osc_cache_debug_dump	(void);
+
+
+/* --- variables --- */
+static GBSearchArray       *cache_entries = NULL;
+static const GBSearchConfig cache_taconfig = {
+  sizeof (OscTableEntry*),
+  cache_table_entry_locs_cmp,
+  0
+};
+static const GBSearchConfig osc_taconfig = {
+  sizeof (OscTableEntry*),
+  osc_table_entry_locs_cmp,
+  0
+};
+
+
+/* --- functions --- */
+static gint
+cache_table_entry_locs_cmp (gconstpointer bsearch_node1, /* key */
+			    gconstpointer bsearch_node2)
+{
+  const OscTableEntry * const *ep1 = bsearch_node1;
+  const OscTableEntry * const *ep2 = bsearch_node2;
+  const OscTableEntry *e1 = *ep1;
+  const OscTableEntry *e2 = *ep2;
+  
+  if (e1->wave_form == e2->wave_form)
+    {
+      if (e1->filter_func == e2->filter_func)
+	return G_BSEARCH_ARRAY_CMP (e1->mfreq, e2->mfreq);
+      else
+	return e1->filter_func > e2->filter_func ? 1 : -1;
+    }
+  else
+    return e1->wave_form > e2->wave_form ? 1 : -1;
+}
+
+static gint
+osc_table_entry_locs_cmp (gconstpointer bsearch_node1, /* key */
+			  gconstpointer bsearch_node2)
+{
+  const OscTableEntry * const *ep1 = bsearch_node1;
+  const OscTableEntry * const *ep2 = bsearch_node2;
+  const OscTableEntry *e1 = *ep1;
+  const OscTableEntry *e2 = *ep2;
+  
+  return G_BSEARCH_ARRAY_CMP (e1->mfreq, e2->mfreq);
+}
+
+static OscTableEntry*
+cache_table_entry_lookup_best (GslOscWaveForm wave_form,
+			       guint8*        filter_func,
+			       gfloat         mfreq)
+{
+  OscTableEntry key, *k = &key, **ep1 = NULL, **ep2, **ep3 = NULL;
+  
+  key.mfreq = mfreq;
+  key.wave_form = wave_form;
+  key.filter_func = filter_func;
+  
+  /* get exact match or a match which is one off into either direction */
+  ep2 = g_bsearch_array_lookup_sibling (cache_entries, &cache_taconfig, &k);
+  if (ep2)
+    {
+      guint i = g_bsearch_array_get_index (cache_entries, &cache_taconfig, ep2);
+      
+      /* get siblings */
+      if (i > 0)
+	ep1 = g_bsearch_array_get_nth (cache_entries, &cache_taconfig, i - 1);
+      if (i + 1 < g_bsearch_array_get_n_nodes (cache_entries))
+	ep3 = g_bsearch_array_get_nth (cache_entries, &cache_taconfig, i + 1);
+      
+      /* get rid of invalid matches, i.e. ones with:
+       * - a different wave
+       * - a different filter
+       * - a filter wider than required
+       */
+      if (ep1 && ((*ep1)->wave_form != wave_form ||
+		  (*ep1)->filter_func != filter_func ||
+		  (*ep1)->mfreq < mfreq))
+	ep1 = NULL;
+      if (ep3 && ((*ep3)->wave_form != wave_form ||
+		  (*ep3)->filter_func != filter_func ||
+		  (*ep3)->mfreq < mfreq))
+	ep3 = NULL;
+      if ((*ep2)->wave_form != wave_form ||
+	  (*ep2)->filter_func != filter_func ||
+	  (*ep2)->mfreq < mfreq)
+	{
+	  /* collapse siblings, so that, if we have valid matches, ep2 is amongst them */
+	  if (ep1)
+	    {
+	      ep2 = ep1;
+	      ep1 = NULL;
+	    }
+	  else if (ep3)
+	    {
+	      ep2 = ep3;
+	      ep3 = NULL;
+	    }
+	  else
+	    ep2 = NULL;	/* no valid match at all */
+	}
+    }
+  
+  /* now figure best out of valid siblings */
+  if (ep2)
+    {
+      if (ep1 && fabs ((*ep1)->mfreq - mfreq) < fabs ((*ep2)->mfreq - mfreq))
+	ep2 = ep1;
+      if (ep3 && fabs ((*ep3)->mfreq - mfreq) < fabs ((*ep2)->mfreq - mfreq))
+	ep2 = ep3;
+    }
+  return ep2 ? *ep2 : NULL;
+}
+
+static OscTableEntry*
+osc_table_entry_lookup_best (const GslOscTable *table,
+			     gfloat             mfreq,
+			     gfloat	       *min_mfreq)
+{
+  OscTableEntry key, *k = &key, **ep;
+  guint i;
+  
+  /* get exact match or a match which is one off into either direction */
+  key.mfreq = mfreq;
+  ep = g_bsearch_array_lookup_sibling (table->entry_array, &osc_taconfig, &k);
+  if_reject (!ep)
+    return NULL;	/* ugh, bad */
+  
+  if (mfreq > (*ep)->mfreq)	/* need better filter */
+    {
+      i = g_bsearch_array_get_index (table->entry_array, &osc_taconfig, ep);
+      if (i + 1 < g_bsearch_array_get_n_nodes (table->entry_array))
+	ep = g_bsearch_array_get_nth (table->entry_array, &osc_taconfig, i + 1);
+      else	/* bad, might cause aliasing */
+	OSC_DEBUG ("lookup mismatch, aliasing possible: want_freq=%f got_freq=%f",
+		   mfreq * table->mix_freq, (*ep)->mfreq * table->mix_freq);
+    }
+  
+  if (min_mfreq)
+    {
+      /* fetch mfreq from previous */
+      i = g_bsearch_array_get_index (table->entry_array, &osc_taconfig, ep);
+      if (i > 0)
+	{
+	  OscTableEntry **tp = g_bsearch_array_get_nth (table->entry_array, &osc_taconfig, i - 1);
+	  
+	  *min_mfreq = (*tp)->mfreq;
+	}
+      else
+	*min_mfreq = 0;
+    }
+  
+  return *ep;
+}
+
+static guint
+wave_table_size (GslOscWaveForm wave_form,
+		 gfloat         mfreq)
+{
+  /* have to return power of 2, and honour 8 <= size */
+  
+  /* FIXME: decide on other table sizes
+  10000: 256
+    5000: 512
+    2500: 1024
+    1250: 2048
+    GSL_OSC_WAVE_SAW_FALL always huge buffers to guarantee pulse width stepping granularity
+  */
+
+  if (wave_form == GSL_OSC_WAVE_SAW_FALL)
+    return 8192;
+
+  return 2048;
+}
+
+static void
+fft_filter (guint    n_values,
+	    gfloat  *values,	/* [0..n_values], n_values/2 complex values */
+	    gdouble  scale_window,
+	    double (*window) (double))
+{
+  guint i;
+
+  n_values >>= 1;
+  scale_window /= (gdouble) n_values;
+  for (i = 0; i <= n_values; i++)
+    {
+      gdouble w = window (i * scale_window);
+      values[i * 2] *= w;
+      values[i * 2 + 1] *= w;
+    }
+}
+
+static OscTableEntry*
+cache_table_ref_entry (GslOscWaveForm wave_form,
+		       double       (*filter_func) (double),
+		       gfloat         mfreq)
+{
+  OscTableEntry *e = cache_table_entry_lookup_best (wave_form, (guint8*) filter_func, mfreq);
+  
+  if (e && !CACHE_MATCH_FREQ (mfreq, e->mfreq))
+    e = NULL;
+  if (!e)
+    {
+      guint size = wave_table_size (wave_form, mfreq);
+      gfloat *values, *fft, step, min, max;
+
+      /* size:
+       * - OscTableEntry already contains the first float values
+       * - we need n_values+1 adressable floats to provide values[0] == values[n_values]
+       */
+      e = g_malloc (sizeof (OscTableEntry) + sizeof (gfloat) * size);
+      values = (gfloat*) &e->values[0];
+      e->wave_form = wave_form;
+      e->filter_func = (guint8*) filter_func;
+      e->mfreq = mfreq;
+      e->ref_count = 1;
+      e->n_values = size;
+      gsl_osc_wave_fill_buffer (e->wave_form, e->n_values, values);
+      
+      /* filter wave accordingly */
+      gsl_osc_wave_extrema (e->n_values, values, &min, &max);
+      fft = g_new (gfloat, e->n_values + 2);	/* [0..n_values] for n_values/2 complex freqs */
+      gsl_power2_fftar_simple (e->n_values, values, fft);
+      step = e->mfreq * (gdouble) e->n_values;
+      fft_filter (e->n_values, fft, step, filter_func);
+      gsl_power2_fftsr_simple (e->n_values, fft, values);
+      g_free (fft);
+      gsl_osc_wave_normalize (e->n_values, values, (min + max) / 2, max);
+
+      /* provide values[0]==values[n_values] */
+      values[e->n_values] = values[0];
+
+      /* pulse min/max pos extension */
+      osc_wave_extrema_pos (e->n_values, values, &e->min_pos, &e->max_pos);
+
+      /* insert into cache */
+      cache_entries = g_bsearch_array_insert (cache_entries, &cache_taconfig, &e);
+    }
+  else
+    e->ref_count++;
+  return e;
+}
+
+static void
+cache_table_unref_entry (OscTableEntry *e)
+{
+  g_return_if_fail (e->ref_count > 0);
+  
+  e->ref_count -= 1;
+  if (e->ref_count == 0)
+    {
+      OscTableEntry **ep;
+      guint i;
+      
+      ep = g_bsearch_array_lookup (cache_entries, &cache_taconfig, &e);
+      i = g_bsearch_array_get_index (cache_entries, &cache_taconfig, ep);
+      cache_entries = g_bsearch_array_remove (cache_entries, &cache_taconfig, i);
+    }
+}
+
+GslOscTable*
+gsl_osc_table_create (gfloat         mix_freq,
+		      GslOscWaveForm wave_form,
+		      double       (*filter_func) (double),
+		      guint          n_freqs,
+		      const gfloat  *freqs)
+{
+  GslOscTable *table;
+  gfloat nyquist;
+  guint i;
+  
+  g_return_val_if_fail (mix_freq > 0, NULL);
+  g_return_val_if_fail (n_freqs > 0, NULL);
+  g_return_val_if_fail (freqs != NULL, NULL);
+  
+  if (!cache_entries)
+    cache_entries = g_bsearch_array_create (&cache_taconfig);
+  
+  table = gsl_new_struct (GslOscTable, 1);
+  table->mix_freq = mix_freq;
+  table->wave_form = wave_form;
+  table->entry_array = g_bsearch_array_create (&osc_taconfig);
+  nyquist = table->mix_freq * 0.5;
+  if (wave_form == GSL_OSC_WAVE_PULSE_SAW)
+    wave_form = GSL_OSC_WAVE_SAW_FALL;
+  for (i = 0; i < n_freqs; i++)
+    {
+      OscTableEntry *e;
+      gdouble mfreq = MIN (nyquist, freqs[i]);
+      
+      mfreq /= table->mix_freq;
+      e = osc_table_entry_lookup_best (table, mfreq, NULL);
+      if (!e || fabs (e->mfreq * table->mix_freq - mfreq * table->mix_freq) > OSC_FREQ_EPSILON)
+	{
+	  e = cache_table_ref_entry (wave_form, filter_func, mfreq);
+	  table->entry_array = g_bsearch_array_insert (table->entry_array, &osc_taconfig, &e);
+	}
+      else if (e)
+	OSC_DEBUG ("not inserting existing entry (freq=%f) for freq %f (nyquist=%f)",
+		   e->mfreq * table->mix_freq, mfreq * table->mix_freq, nyquist);
+    }
+  
+  return table;
+}
+
+void
+gsl_osc_table_lookup (const GslOscTable	*table,
+		      gfloat		 freq,
+		      GslOscWave	*wave)
+{
+  OscTableEntry *e;
+  gfloat mfreq, min_mfreq;
+
+  g_return_if_fail (table != NULL);
+  g_return_if_fail (wave != NULL);
+  
+  mfreq = freq / table->mix_freq;
+  e = osc_table_entry_lookup_best (table, mfreq, &min_mfreq);
+  if (e)
+    {
+      guint32 int_one;
+      gfloat float_one;
+
+      wave->min_freq = min_mfreq * table->mix_freq;
+      wave->max_freq = e->mfreq * table->mix_freq;
+      wave->n_values = e->n_values;
+      wave->values = e->values;
+      wave->n_frac_bits = g_bit_storage (wave->n_values - 1);
+      wave->n_frac_bits = 32 - wave->n_frac_bits;
+      int_one = 1 << wave->n_frac_bits;
+      wave->frac_bitmask = int_one - 1;
+      float_one = int_one;
+      wave->freq_to_step = float_one * wave->n_values / table->mix_freq;
+      wave->phase_to_pos = wave->n_values * float_one;
+      wave->ifrac_to_float = 1.0 / float_one;
+      /* pulse min/max pos extension */
+      wave->min_pos = e->min_pos;
+      wave->max_pos = e->max_pos;
+    }
+  else
+    {
+      /* shouldn't happen */
+      OSC_DEBUG ("table lookup revealed NULL, empty table?");
+      memset (wave, 0, sizeof (*wave));
+    }
+}
+
+void
+gsl_osc_table_free (GslOscTable *table)
+{
+  guint n;
+  
+  g_return_if_fail (table != NULL);
+  
+  n = g_bsearch_array_get_n_nodes (table->entry_array);
+  while (n--)
+    {
+      OscTableEntry **ep;
+      
+      ep = g_bsearch_array_get_nth (table->entry_array, &osc_taconfig, n);
+      cache_table_unref_entry (*ep);
+      table->entry_array = g_bsearch_array_remove (table->entry_array, &osc_taconfig, n);
+    }
+  g_bsearch_array_free (table->entry_array, &osc_taconfig);
+  gsl_delete_struct (GslOscTable, table);
+}
+
+void
+gsl_osc_cache_debug_dump (void)
+{
+  OSC_DEBUG ("left in cache: %u", g_bsearch_array_get_n_nodes (cache_entries));
+}
+
+void
+gsl_osc_wave_fill_buffer (GslOscWaveForm type,
+			  guint	         n_values,
+			  gfloat	*values)
+{
+  gdouble max = n_values, hmax = max * 0.5, qmax = n_values * 0.25;
+  gint i, half = n_values / 2, quarter = half / 2;
+  
+  switch (type)
+    {
+      gdouble frac, pos;
+    case GSL_OSC_WAVE_SINE:
+      for (i = 0; i < n_values; i++)
+	{
+	  frac = ((gdouble) i) / max; /* [0..1[ */
+	  pos = frac * 2. * GSL_PI;
+	  values[i] = sin (pos);
+	}
+      break;
+    case GSL_OSC_WAVE_SAW_RISE:
+      for (i = 0; i < n_values; i++)
+	{
+	  frac = ((gdouble) i) / max; /* [0..1[ */
+	  values[i] = 2.0 * frac - 1.0;
+	}
+      break;
+    case GSL_OSC_WAVE_SAW_FALL:
+      for (i = 0; i < n_values; i++)
+	{
+	  frac = ((gdouble) i) / max; /* [0..1[ */
+	  values[i] = 1.0 - 2.0 * frac;
+	}
+      break;
+    case GSL_OSC_WAVE_PEAK_RISE:	/* spaced saw */
+      for (i = 0; i < half; i++)
+	{
+	  frac = ((gdouble) i) / hmax;
+          values[i] = 2.0 * frac - 1.0;
+	}
+      for (; i < n_values; i++)
+	values[i] = -1.0;
+      break;
+    case GSL_OSC_WAVE_PEAK_FALL:	/* spaced saw */
+      for (i = 0; i < half; i++)
+	{
+	  frac = ((gdouble) i) / hmax;
+          values[i] = 1.0 - 2.0 * frac;
+	}
+      for (; i < n_values; i++)
+	values[i] = -1.0;
+      break;
+    case GSL_OSC_WAVE_TRIANGLE:
+      for (i = 0; i < quarter; i++)
+	{
+	  frac = ((gdouble) i) / qmax;
+	  values[i] = frac;
+	}
+      for (; i < half + quarter; i++)
+	{
+	  frac = ((gdouble) i - quarter) / hmax;
+          values[i] = 1.0 - 2.0 * frac;
+	}
+      for (; i < n_values; i++)
+	{
+	  frac = ((gdouble) i - half - quarter) / qmax;
+	  values[i] = frac - 1.0;
+	}
+      break;
+    case GSL_OSC_WAVE_MOOG_SAW:
+      for (i = 0; i < half; i++)
+	{
+	  frac = ((gdouble) i) / hmax;
+          values[i] = 2.0 * frac - 1.0;
+	}
+      for (; i < n_values; i++)
+	{
+	  frac = ((gdouble) i) / max;
+          values[i] = 1.0 - 2.0 * frac;
+	}
+      break;
+    case GSL_OSC_WAVE_SQUARE:
+      for (i = 0; i < half; i++)
+	values[i] = 1.0;
+      for (; i < n_values; i++)
+	values[i] = -1.0;
+      break;
+    default:
+      g_critical ("%s: invalid wave form id (%u)", G_STRLOC, type);
+    case GSL_OSC_WAVE_NONE:
+      for (i = 0; i < n_values; i++)
+	values[i] = 0;
+      break;
+    }
+}
+
+static void
+osc_wave_extrema_pos (guint          n_values,
+		      const gfloat *values,
+		      guint        *minp_p,
+		      guint        *maxp_p)
+{
+  guint i, minp = 0, maxp = 0;
+  gfloat min = values[0], max = min;
+
+  for (i = 1; i < n_values; i++)
+    {
+      if (values[i] > max)
+	{
+	  max = values[i];
+	  maxp = i;
+	}
+      else if (values[i] < min)
+	{
+	  min = values[i];
+	  minp = i;
+	}
+    }
+  *minp_p = minp;
+  *maxp_p = maxp;
+}
+
+void
+gsl_osc_wave_extrema (guint         n_values,
+		      const gfloat *values,
+		      gfloat       *min_p,
+		      gfloat       *max_p)
+{
+  guint minp, maxp;
+
+  g_return_if_fail (n_values > 0 && values != NULL && min_p != NULL && max_p != NULL);
+
+  osc_wave_extrema_pos (n_values, values, &minp, &maxp);
+  *min_p = values[minp];
+  *max_p = values[maxp];
+}
+
+void
+gsl_osc_wave_adjust_range (guint   n_values,
+			   gfloat *values,
+			   gfloat  min,
+			   gfloat  max,
+			   gfloat  new_center,
+			   gfloat  new_max)
+{
+  gfloat center;
+  guint i;
+  
+  g_return_if_fail (n_values > 0 && values != NULL);
+
+  center = (min + max) / 2;
+  center = new_center - center;
+  min = fabs (min + center);
+  max = fabs (max + center);
+  if (min > max)
+    max = min;
+  if (max > GSL_FLOAT_MIN_NORMAL)
+    max = new_max / max;
+  else
+    max = 0;
+  for (i = 0; i < n_values; i++)
+    values[i] = (values[i] + center) * max;
+}
+
+void
+gsl_osc_wave_normalize (guint   n_values,
+			gfloat *values,
+			gfloat  new_center,
+			gfloat  new_max)
+{
+  gfloat min, max;
+  guint i;
+
+  g_return_if_fail (n_values > 0 && values != NULL);
+
+  min = values[0];
+  max = min;
+  for (i = 1; i < n_values; i++)
+    {
+      register gfloat v = values[i];
+
+      max = MAX (max, v);
+      min = MIN (min, v);
+    }
+
+  gsl_osc_wave_adjust_range (n_values, values, min, max, new_center, new_max);
+}
diff --git a/flow/gsl/gslosctable.h b/flow/gsl/gslosctable.h
new file mode 100644
index 0000000..021e5b9
--- /dev/null
+++ b/flow/gsl/gslosctable.h
@@ -0,0 +1,104 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_OSC_TABLE_H__
+#define __GSL_OSC_TABLE_H__
+
+#include <gsl/gsldefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- structures & enums --- */
+typedef enum    /*< skip >*/
+{
+  GSL_OSC_WAVE_NONE,
+  GSL_OSC_WAVE_SINE,
+  GSL_OSC_WAVE_TRIANGLE,
+  GSL_OSC_WAVE_SAW_RISE,
+  GSL_OSC_WAVE_SAW_FALL,
+  GSL_OSC_WAVE_PEAK_RISE,
+  GSL_OSC_WAVE_PEAK_FALL,
+  GSL_OSC_WAVE_MOOG_SAW,
+  GSL_OSC_WAVE_SQUARE,
+  GSL_OSC_WAVE_PULSE_SAW
+} GslOscWaveForm;
+
+typedef struct
+{
+  gfloat         mix_freq;
+  GslOscWaveForm wave_form;
+  gpointer       entry_array;
+} GslOscTable;
+
+typedef struct
+{
+  gfloat        min_freq;
+  gfloat        max_freq;
+  guint         n_values;
+  const gfloat *values;	/* contains n_values+1 values with values[0]==values[n_values] */
+  /* integer stepping (block size dependant) */
+  guint32	n_frac_bits;
+  guint32	frac_bitmask;
+  gfloat	freq_to_step;		/* freq -> int.frac */
+  gfloat	phase_to_pos;		/* 0..1 -> int.frac */
+  gfloat	ifrac_to_float;		/* frac -> 0..1 float */
+  guint		min_pos, max_pos;	/* pulse extension */
+} GslOscWave;
+
+
+/* --- oscillator table --- */
+GslOscTable*    gsl_osc_table_create            (gfloat                  mix_freq,
+						 GslOscWaveForm          wave_form,
+						 double                (*filter_func) (double),
+						 guint                   n_freqs,
+						 const gfloat           *freqs);
+void            gsl_osc_table_lookup            (const GslOscTable      *table,
+						 gfloat                  freq,
+						 GslOscWave             *wave);
+void            gsl_osc_table_free              (GslOscTable            *table);
+
+
+/* --- oscillator wave utils --- */
+void            gsl_osc_wave_fill_buffer        (GslOscWaveForm          type,
+						 guint                   n_values,
+						 gfloat                 *values);
+void		gsl_osc_wave_extrema		(guint                   n_values,
+						 const gfloat		*values,
+						 gfloat			*min,
+						 gfloat			*max);
+void		gsl_osc_wave_normalize		(guint			 n_values,
+						 gfloat			*values,
+						 gfloat			 new_center,
+						 gfloat			 new_max);
+void		gsl_osc_wave_adjust_range	(guint			 n_values,
+						 gfloat			*values,
+						 gfloat			 min,
+						 gfloat			 max,
+						 gfloat			 new_center,
+						 gfloat			 new_max);
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_OSC_TABLE_H__ */
diff --git a/flow/gsl/gslsignal.c b/flow/gsl/gslsignal.c
new file mode 100644
index 0000000..9afc5bb
--- /dev/null
+++ b/flow/gsl/gslsignal.c
@@ -0,0 +1,258 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslsignal.h"
+
+#include "gslcommon.h"
+
+
+/* --- frequency modulation --- */
+void
+gsl_frequency_modulator (const GslFrequencyModulator *fm,
+			 guint                        n_values,
+			 const gfloat                *ifreq,
+			 const gfloat                *ifmod,
+			 gfloat                      *fm_buffer)
+{
+  gfloat *bound, fine_tune, fm_strength;
+  gboolean with_fine_tune;
+
+  fine_tune = gsl_cent_factor (fm->fine_tune);
+  with_fine_tune = fm->fine_tune != 0;
+  fm_strength = fm->fm_strength;
+  
+  bound = fm_buffer + n_values;
+  if (ifreq && ifmod)
+    {
+      if (fm->exponential_fm)
+	{
+	  if (with_fine_tune)
+	    do {
+	      *fm_buffer++ = *ifreq++ * gsl_approx_exp2 (fm_strength * *ifmod++) * fine_tune;
+	    } while (fm_buffer < bound);
+	  else
+	    do {
+	      *fm_buffer++ = *ifreq++ * gsl_approx_exp2 (fm_strength * *ifmod++);
+	    } while (fm_buffer < bound);
+	}
+      else
+	{
+	  if (with_fine_tune)
+	    do {
+	      *fm_buffer++ = *ifreq++ * (1 + fm_strength * *ifmod++) * fine_tune;
+	    } while (fm_buffer < bound);
+	  else
+	    do {
+	      *fm_buffer++ = *ifreq++ * (1 + fm_strength * *ifmod++);
+	    } while (fm_buffer < bound);
+	}
+    }
+  else if (ifmod)
+    {
+      gfloat signal_freq = fm->signal_freq * fine_tune;
+
+      if (fm->exponential_fm)
+	do {
+	  *fm_buffer++ = signal_freq * gsl_approx_exp2 (fm_strength * *ifmod++);
+	} while (fm_buffer < bound);
+      else
+	do {
+	  *fm_buffer++ = signal_freq * (1 + fm_strength * *ifmod++);
+	} while (fm_buffer < bound);
+    }
+  else if (ifreq)
+    {
+      if (with_fine_tune)
+	do {
+	  *fm_buffer++ = *ifreq++ * fine_tune;
+	} while (fm_buffer < bound);
+      else
+	do {
+	  *fm_buffer++ = *ifreq++;
+	} while (fm_buffer < bound);
+    }
+  else
+    {
+      gfloat signal_freq = fm->signal_freq * fine_tune;
+
+      do {
+	*fm_buffer++ = signal_freq;
+      } while (fm_buffer < bound);
+    }
+}
+
+
+/* --- windows --- */
+double
+gsl_window_bartlett (double x)	/* triangle */
+{
+  if (fabs (x) > 1)
+    return 0;
+
+  return 1.0 - fabs (x);
+}
+
+double
+gsl_window_blackman (double x)
+{
+  if (fabs (x) > 1)
+    return 0;
+
+  return 0.42 + 0.5 * cos (GSL_PI * x) + 0.08 * cos (2.0 * GSL_PI * x);
+}
+
+double
+gsl_window_cos (double x)	/* von Hann window */
+{
+  if (fabs (x) > 1)
+    return 0;
+
+  return 0.5 * cos (x * GSL_PI) + 0.5;
+}
+
+double
+gsl_window_hamming (double x)	/* sharp (rectangle) cutoffs at boundaries */
+{
+  if (fabs (x) > 1)
+    return 0;
+
+  return 0.54 + 0.46 * cos (GSL_PI * x);
+}
+
+double
+gsl_window_sinc (double x)	/* noramlied C. Lanczos window */
+{
+  if (fabs (x) > 1)
+    return 0;
+  x = x * GSL_PI;
+  if (fabs (x) < 1e-12)
+    return 1.0;
+  else
+    return sin (x) / x;
+}
+
+double
+gsl_window_rect (double x)	/* a square */
+{
+  if (fabs (x) > 1)
+    return 0;
+  return 1.0;
+}
+
+/*
+cos_roll_off(x)= x>fh?0:x<fl?1:cos(pi/2.*((fl-x)/(fh-fl))) 
+*/
+
+
+/* --- cents & init --- */
+const gdouble *gsl_cent_table = NULL;
+#define GSL_2_RAISED_TO_1_OVER_1200_d     ( /* 2^(1/1200) */ \
+              1.0005777895065548488418016859213821589946746826171875)
+void
+_gsl_init_signal (void)
+{
+  static gdouble cent_table_space[201];
+  gint i;
+
+  /* cent table initialization,
+   * allow negative indexing within [-100..+100]
+   */
+  gsl_cent_table = cent_table_space + 100;
+  for (i = -100; i <= 100; i++)
+    cent_table_space[100 + i] = pow (GSL_2_RAISED_TO_1_OVER_1200_d, i);
+}
+
+
+/* --- gsl_approx_atan1() --- */
+double
+gsl_approx_atan1_prescale (double boost_amount)
+{
+  double max_boost_factor = 100;	/* atan1(x*100) gets pretty close to 1 for x=1 */
+  double recip_tan_1_div_0_75 = 0.24202942695518667705824990442766; /* 1/tan(1/0.75) */
+  double scale;
+
+  g_return_val_if_fail (boost_amount >= 0 && boost_amount <= 1.0, 1.0);
+
+  /* scale boost_amount from [0..1] to -1..1 */
+  boost_amount = boost_amount * 2 - 1.0;
+
+  /* prescale factor for atan1(x*prescale), ranges from 1/max_boost_factor..max_boost_factor */
+  scale = pow (max_boost_factor, tan (boost_amount / 0.75) * recip_tan_1_div_0_75);
+
+  return scale;
+}
+
+
+/* --- exp2f() approximation taylor coefficients finder --- */
+#if 0
+#include <stdio.h>
+double
+exp2coeff (int n)
+{
+  double r = 1;
+  int i;
+
+  for (i = 1; i <= n; i++)
+    {
+      r *= GSL_LN2;
+      r /= i;
+    }
+  return r;
+}
+/* generate taylor coefficients */
+int
+main (int   argc,
+      char *argv[])
+{
+  int i;
+
+  for (i = 0; i < 20; i++)
+    printf ("#define EXP2_TAYLOR_COEFF_%u\t(%.40f)\n", i, exp2coeff (i));
+
+  return 0;
+}
+/* test/bench program */
+#define _GNU_SOURCE
+#include <math.h>
+int
+main (int   argc,
+      char *argv[])
+{
+  double x, dummy = 0, l = 4;
+
+  if (1)	/* print errors */
+    for (x = -3; x < 3.01; x += 0.1)
+      {
+	g_print ("%+f %+1.20f \t (%.20f - %.20f)\n",
+		 x, exp (x * GSL_LN2) - gsl_signal_exp2 (x),
+		 exp (x * GSL_LN2), gsl_signal_exp2 (x));
+      }
+
+  if (0)	/* bench test */
+    for (x = -l; x < l; x += 0.000001)
+      {
+	dummy += gsl_signal_exp2 (x);
+	// dummy += exp2f (x);
+      }
+
+  g_print ("%f\r                            \n", dummy);
+
+  return 0;
+}
+#endif  /* coeff generation */
+
diff --git a/flow/gsl/gslsignal.h b/flow/gsl/gslsignal.h
new file mode 100644
index 0000000..aa92f32
--- /dev/null
+++ b/flow/gsl/gslsignal.h
@@ -0,0 +1,343 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_SIGNAL_H__
+#define __GSL_SIGNAL_H__
+
+#include <gsl/gsldefs.h>
+#include <gsl/gslieee754.h>
+#include <gsl/gslmath.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* smallest value of a signal sample, greater than zero
+ */
+#define GSL_SIGNAL_EPSILON      (1.15e-14)      /* 1.16415321826934814453125e-9 ~= 1/2^33 */
+
+/* maximum value of a signal sample
+ */
+#define GSL_SIGNAL_KAPPA        (1.5)
+
+/* catch edges in sync signals.
+ * sync signals should be constant, do comparing against
+ * an epsilon just hurts speed in the common case
+ */
+#define GSL_SIGNAL_RAISING_EDGE(v1,v2)	((v1) < (v2))
+#define GSL_SIGNAL_FALLING_EDGE(v1,v2)	((v1) > (v2))
+
+/* value changes in signals which represent frequencies
+ */
+#define GSL_SIGNAL_FREQ_CHANGED(v1,v2)	(fabs ((v1) - (v2)) > 1e-7)
+
+/* value changes in signals which represent modulation
+ */
+#define GSL_SIGNAL_MOD_CHANGED(v1,v2)	(fabs ((v1) - (v2)) > 1e-8)
+
+/* value changes in signals which represent dB ranges
+ */
+#define GSL_SIGNAL_GAIN_CHANGED(v1,v2)	(fabs ((v1) - (v2)) > 1e-8)
+
+/* convert between literal frequencies and signal values
+ */
+#if defined (BSE_COMPILATION) || defined (BSE_PLUGIN_FALLBACK)
+#include <bse/bseglobals.h>
+#  define GSL_SIGNAL_TO_FREQ_FACTOR	(BSE_MAX_FREQUENCY_f)
+#  define GSL_SIGNAL_FROM_FREQ_FACTOR	(1.0 / BSE_MAX_FREQUENCY_f)
+#  define GSL_SIGNAL_TO_FREQ(value)	(((gfloat) (value)) * GSL_SIGNAL_TO_FREQ_FACTOR)
+#  define GSL_SIGNAL_FROM_FREQ(freq)	(((gfloat) (freq)) * GSL_SIGNAL_FROM_FREQ_FACTOR)
+#elif defined (GSL_USE_ARTS_THREADS)  /* must be aRts */
+#  define GSL_SIGNAL_TO_FREQ(x)		(x)
+#  define GSL_SIGNAL_FROM_FREQ(x)	(x)
+#endif
+
+
+/* --- frequency modulation --- */
+typedef struct {
+  gfloat	fm_strength;		/* linear: 0..1, exponential: n_octaves */
+  guint		exponential_fm : 1;
+  gfloat	signal_freq;		/* for ifreq == NULL (as GSL_SIGNAL_FROM_FREQ) */
+  gint		fine_tune;		/* -100..+100 */
+} GslFrequencyModulator;
+
+void	gsl_frequency_modulator	(const GslFrequencyModulator	*fm,
+				 guint				 n_values,
+				 const gfloat			*ifreq,
+				 const gfloat			*ifmod,
+				 gfloat				*fm_buffer);
+
+
+/* --- function approximations --- */
+
+/**
+ * gsl_signal_exp2
+ * Deprecated in favour of gsl_approx_exp2().
+ */
+static inline float	gsl_signal_exp2 (float x)  G_GNUC_CONST;
+
+/**
+ * gsl_approx_exp2
+ * @ex:      exponent within [-127..127]
+ * @RETURNS: y approximating 2^x
+ * Fast approximation of 2 raised to the power of x.
+ * Multiplicative error stays below 8e-6 and aproaches zero
+ * for integer values of x (i.e. x - floor (x) = 0).
+ */
+static inline double	gsl_approx_exp2	(float ex)	G_GNUC_CONST;
+
+
+/**
+ * gsl_approx_atan1
+ * Fast atan(x)/(PI/2) approximation, with maximum error < 0.01 and
+ * gsl_approx_atan1(0)==0, according to the formula:
+ * n1 = -0.41156875521951602506487246309908;
+ * n2 = -1.0091272542790025586079663559158;
+ * d1 = 0.81901156857081841441890603235599;
+ * d2 = 1.0091272542790025586079663559158;
+ * positive_atan1(x) = 1 + (n1 * x + n2) / ((1 + d1 * x) * x + d2);
+ */
+static inline double	gsl_approx_atan1 	  (register double x)  G_GNUC_CONST;
+
+/**
+ * gsl_approx_atan1_prescale
+ * @boost_amount: boost amount between [0..1]
+ * @RETURNS:      prescale factor for gsl_approx_atan1()
+ * Calculate the prescale factor for gsl_approx_atan1(x*prescale) from
+ * a linear boost factor, where 0.5 amounts to prescale=1.0, 1.0 results
+ * in maximum boost and 0.0 results in maximum attenuation.
+ */
+double			gsl_approx_atan1_prescale (double	   boost_amount);
+
+/**
+ * gsl_approx_qcircle1
+ * @x:       x within [0..1]
+ * @RETURNS: y for circle approximation within [0..1]
+ * Fast approximation of the upper right quadrant of a circle.
+ * Errors at x=0 and x=1 are zero, for the rest of the curve, the error
+ * wasn't minimized, but distributed to best fit the curverture of a
+ * quarter circle. The maximum error is below 0.092.
+ */
+static inline double	gsl_approx_qcircle1	  (register double x)  G_GNUC_CONST;
+
+/**
+ * gsl_approx_qcircle2
+ * @x:       x within [0..1]
+ * @RETURNS: y for circle approximation within [0..1]
+ * Fast approximation of the upper left quadrant of a circle.
+ * Errors at x=0 and x=1 are zero, for the rest of the curve, the error
+ * wasn't minimized, but distributed to best fit the curverture of a
+ * quarter circle. The maximum error is below 0.092.
+ */
+static inline double	gsl_approx_qcircle2	  (register double x)  G_GNUC_CONST;
+
+/**
+ * gsl_approx_qcircle3
+ * @x:       x within [0..1]
+ * @RETURNS: y for circle approximation within [0..1]
+ * Fast approximation of the lower left quadrant of a circle.
+ * Errors at x=0 and x=1 are zero, for the rest of the curve, the error
+ * wasn't minimized, but distributed to best fit the curverture of a
+ * quarter circle. The maximum error is below 0.092.
+ */
+static inline double	gsl_approx_qcircle3	  (register double x)  G_GNUC_CONST;
+
+/**
+ * gsl_approx_qcircle4
+ * @x:       x within [0..1]
+ * @RETURNS: y for circle approximation within [0..1]
+ * Fast approximation of the lower right quadrant of a circle.
+ * Errors at x=0 and x=1 are zero, for the rest of the curve, the error
+ * wasn't minimized, but distributed to best fit the curverture of a
+ * quarter circle. The maximum error is below 0.092.
+ */
+static inline double	gsl_approx_qcircle4	  (register double x)  G_GNUC_CONST;
+
+
+/* --- windows --- */
+double	gsl_window_bartlett	(double x);	/* narrowest */
+double	gsl_window_blackman	(double x);
+double	gsl_window_cos		(double x);
+double	gsl_window_hamming	(double x);
+double	gsl_window_sinc		(double x);
+double	gsl_window_rect		(double x);	/* widest */
+
+
+/* --- cents (1/100th of a semitone) --- */
+#define	gsl_cent_factor(index /* -100..100 */)	(gsl_cent_table[index])
+extern const gdouble *gsl_cent_table;
+
+
+/* --- implementation details --- */
+static inline double  G_GNUC_CONST
+gsl_approx_atan1 (register double x)
+{
+  if (x < 0)	/* make use of -atan(-x)==atan(x) */
+    {
+      register double numerator, denominator = -1.0;
+
+      denominator += x * 0.81901156857081841441890603235599; /* d1 */
+      numerator = x * 0.41156875521951602506487246309908; /* -n1 */
+      denominator *= x;
+      numerator += -1.0091272542790025586079663559158; /* n2 */
+      denominator += 1.0091272542790025586079663559158; /* d2 */
+
+      return -1.0 - numerator / denominator;
+    }
+  else
+    {
+      register double numerator, denominator = 1.0;
+
+      denominator += x * 0.81901156857081841441890603235599; /* d1 */
+      numerator = x * -0.41156875521951602506487246309908; /* n1 */
+      denominator *= x;
+      numerator += -1.0091272542790025586079663559158; /* n2 */
+      denominator += 1.0091272542790025586079663559158; /* d2 */
+
+      return 1.0 + numerator / denominator;
+    }
+}
+
+static inline double	G_GNUC_CONST
+gsl_approx_qcircle1 (register double x)
+{
+  double numerator = 1.20460124790369468987715633298929 * x - 1.20460124790369468987715633298929;
+  double denominator = x - 1.20460124790369468987715633298929;
+  /* R1(x)=(1.2046012479036946898771563 * x - 1.2046012479036946898771563) / (x - 1.2046012479036946898771563) */
+  return numerator / denominator;
+}
+
+static inline double	G_GNUC_CONST
+gsl_approx_qcircle2 (register double x)
+{
+  double numerator = 1.20460124790369468987715633298929*x;
+  double denominator = x + 0.20460124790369468987715633298929;
+  /* R2(x)=1.2046012479036946898771563*x/(x + 0.2046012479036946898771563) */
+  return numerator / denominator;
+}
+
+static inline double	G_GNUC_CONST
+gsl_approx_qcircle3 (register double x)
+{
+  double numerator = 0.20460124790369468987715633298929 - 0.20460124790369468987715633298929 * x;
+  double denominator = x + 0.20460124790369468987715633298929;
+  /* R3(x)=(0.2046012479036946898771563 - 0.2046012479036946898771563 * x) / (x + 0.2046012479036946898771563) */
+  return numerator / denominator;
+}
+
+static inline double	G_GNUC_CONST
+gsl_approx_qcircle4 (register double x)
+{
+  double numerator = -0.20460124790369468987715633298929 * x;
+  double denominator = x - 1.20460124790369468987715633298929;
+  /* R4(x)=-0.2046012479036946898771563 * x / (x - 1.2046012479036946898771563) */
+  return numerator / denominator;
+}
+
+static inline double G_GNUC_CONST
+gsl_approx_exp2 (float ex)
+{
+  register GslFloatIEEE754 fp = { 0, };
+  register double numer, denom, x;
+  gint i;
+
+  i = gsl_ftoi (ex);
+  fp.mpn.biased_exponent = GSL_FLOAT_BIAS + i;
+  x = ex - i;
+  numer = x * 1.022782938747283388104723674300322141276;
+  denom = x - 8.72117024533378044415954808601135282456;
+  numer += 8.786902350800703562041965087953613538091;
+  denom *= x;
+  numer *= x;
+  denom += 25.25880955504064143887016455761526606757;
+  numer += 25.2588095552441757401874424757283407864;
+
+  return numer / denom * fp.v_float;
+}
+
+static inline float  G_GNUC_CONST
+_gsl_signal_exp2_fraction (float x)	/* 2^x, -0.5 <= x <= 0.5 */
+{
+  static const float exp2taylorC0 = 1.0000000000000000000000000000000000000000;
+  static const float exp2taylorC1 = 0.6931471805599452862267639829951804131269;
+  static const float exp2taylorC2 = 0.2402265069591006940719069007172947749496;
+  static const float exp2taylorC3 = 0.0555041086648215761800706502526736585423;
+  static const float exp2taylorC4 = 0.0096181291076284768787330037298488605302;
+  static const float exp2taylorC5 = 0.0013333558146428443284131626356270317046;
+#if 0
+  static const float exp2taylorC6 = 0.0001540353039338160877607525334198612654;
+  static const float exp2taylorC7 = 0.0000152527338040598393887042200089965149;
+  static const float exp2taylorC8 = 0.0000013215486790144307390984122416166535;
+  static const float exp2taylorC9 = 0.0000001017808600923969859895309888857262;
+#endif
+  float r = 0.0;
+
+  /* order 5 taylor series aproximation */
+  r += exp2taylorC5;
+  r *= x;
+  r += exp2taylorC4;
+  r *= x;
+  r += exp2taylorC3;
+  r *= x;
+  r += exp2taylorC2;
+  r *= x;
+  r += exp2taylorC1;
+  r *= x;
+  r += exp2taylorC0;
+
+  return r;
+}
+static inline float  G_GNUC_CONST
+gsl_signal_exp2 (float x)		/* 2^x, -3.5 <= x <= 3.5, prec>16bit */
+{
+  if_reject (x < -0.5)
+    {
+      if_reject (x < -1.5)
+	{
+	  if (x < -2.5)
+	    return 0.125 * _gsl_signal_exp2_fraction (x + 3);
+	  else /* -2.5 <= x < -1.5 */
+	    return 0.25 * _gsl_signal_exp2_fraction (x + 2);
+	}
+      else /* -1.5 <= x < -0.5 */
+	return 0.5 * _gsl_signal_exp2_fraction (x + 1);
+    }
+  else if_reject (x > 0.5)
+    {
+      if_reject (x > 1.5)
+	{
+	  if (x > 2.5)
+	    return 8 * _gsl_signal_exp2_fraction (x - 3);
+	  else /* 1.5 < x <= 2.5 */
+	    return 4 * _gsl_signal_exp2_fraction (x - 2);
+	}
+      else /* 0.5 < x <= 1.5 */
+	return 2 * _gsl_signal_exp2_fraction (x - 1);
+    }
+  else
+    return _gsl_signal_exp2_fraction (x);
+}
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_SIGNAL_H__ */
diff --git a/flow/gsl/gsltests.c b/flow/gsl/gsltests.c
new file mode 100644
index 0000000..12a1664
--- /dev/null
+++ b/flow/gsl/gsltests.c
@@ -0,0 +1,650 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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 <gsl/gslmath.h>
+#include <gsl/gslcommon.h>
+#include <gsl/gslmath.h>
+#include <gsl/gslfilter.h>
+#include <gsl/gslloader.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define PREC    "15"
+
+
+static void	usage (void)	G_GNUC_NORETURN;
+
+
+static guint         shift_argc = 0;
+static const gchar **shift_argv = NULL;
+
+static const gchar*
+shift (void)
+{
+  const gchar *arg;
+
+  if (shift_argc > 1)
+    {
+      shift_argc--;
+      arg = shift_argv++[1];
+      if (!arg)
+	arg = "";
+    }
+  else
+    arg = NULL;
+  return arg;
+}
+static const gchar*
+pshift (void)
+{
+  const gchar *arg = shift ();
+
+  return arg ? arg : "";
+}
+
+int
+main (int   argc,
+      char *argv[])
+{
+  const gchar *arg;
+
+  /* iir filter parameters */
+  enum { FILTER_GNUPLOT, FILTER_SCAN } filter_mode = FILTER_GNUPLOT;
+  const gchar *filter_label = 0;
+  gdouble *a, *b;
+  guint order = 0;
+
+  shift_argc = argc;
+  shift_argv = (gchar **)argv;
+
+  if (!g_thread_supported ())
+      g_thread_init (NULL);
+  gsl_init (NULL, NULL);
+
+  arg = shift ();
+  if (!arg)
+    usage ();
+
+ restart:
+  a = b = 0;
+
+  if (strcmp (arg, "wave-scan") == 0)
+    {
+      const gchar *file = pshift ();
+
+      while (file)
+	{
+	  GslWaveFileInfo *fi;
+	  GslErrorType error;
+
+	  fi = gsl_wave_file_info_load (file, &error);
+	  if (fi)
+	    {
+	      guint i;
+
+	      g_print ("Loader \"%s\" found %u waves in \"%s\":\n", fi->loader->name, fi->n_waves, file);
+	      for (i = 0; i < fi->n_waves; i++)
+		g_print ("%u) %s\n", i + 1, fi->waves[i].name);
+	      gsl_wave_file_info_unref (fi);
+	    }
+	  else
+	    g_print ("Failed to scan \"%s\": %s\n", file, gsl_strerror (error));
+	  file = pshift ();
+	  if (!file[0])
+	    break;
+	}
+    }
+  else if (strcmp (arg, "file-test") == 0)
+    {
+      const gchar *file = pshift ();
+
+      g_print ("file test for \"%s\":\n", file);
+      g_print ("  is readable   : %s\n", gsl_strerror (gsl_check_file (file, "r")));
+      g_print ("  is writable   : %s\n", gsl_strerror (gsl_check_file (file, "w")));
+      g_print ("  is executable : %s\n", gsl_strerror (gsl_check_file (file, "x")));
+      g_print ("  is file       : %s\n", gsl_strerror (gsl_check_file (file, "f")));
+      g_print ("  is directory  : %s\n", gsl_strerror (gsl_check_file (file, "d")));
+      g_print ("  is link       : %s\n", gsl_strerror (gsl_check_file (file, "l")));
+    }
+  else if (strcmp (arg, "rf") == 0)
+    {
+      double x, y, z;
+      x = atof (pshift ());
+      y = atof (pshift ());
+      z = atof (pshift ());
+
+      g_print ("rf(%f, %f, %f) = %."PREC"f\n", x, y, z, gsl_ellip_rf (x, y, z));
+    }
+  else if (strcmp (arg, "F") == 0)
+    {
+      double phi, ak;
+      phi = atof (pshift ());
+      ak = atof (pshift ());
+
+      g_print ("F(%f, %f) = %."PREC"f\n", phi, ak, gsl_ellip_F (phi, ak));
+    }
+  else if (strcmp (arg, "sn") == 0)
+    {
+      double u, emmc;
+      u = atof (pshift ());
+      emmc = atof (pshift ());
+
+      g_print ("sn(%f, %f) = %."PREC"f\n", u, emmc, gsl_ellip_sn (u, emmc));
+    }
+  else if (strcmp (arg, "snc") == 0)
+    {
+      GslComplex u, emmc;
+      u.re = atof (pshift ());
+      u.im = atof (pshift ());
+      emmc.re = atof (pshift ());
+      emmc.im = atof (pshift ());
+
+      g_print ("snc(%s, %s) = %s\n",
+	       gsl_complex_str (u),
+	       gsl_complex_str (emmc),
+	       gsl_complex_str (gsl_complex_ellip_sn (u, emmc)));
+    }
+  else if (strcmp (arg, "sci_snc") == 0)
+    {
+      GslComplex u, k2;
+      u.re = atof (pshift ());
+      u.im = atof (pshift ());
+      k2.re = atof (pshift ());
+      k2.im = atof (pshift ());
+
+      g_print ("sci_snc(%s, %s) = %s\n",
+	       gsl_complex_str (u),
+	       gsl_complex_str (k2),
+	       gsl_complex_str (gsl_complex_ellip_sn (u, gsl_complex_sub (gsl_complex (1.0, 0), k2))));
+    }
+  else if (strcmp (arg, "asn") == 0)
+    {
+      double y, emmc;
+      y = atof (pshift ());
+      emmc = atof (pshift ());
+
+      g_print ("asn(%f, %f) = %."PREC"f\n", y, emmc, gsl_ellip_asn (y, emmc));
+    }
+  else if (strcmp (arg, "asnc") == 0)
+    {
+      GslComplex y, emmc;
+      y.re = atof (pshift ());
+      y.im = atof (pshift ());
+      emmc.re = atof (pshift ());
+      emmc.im = atof (pshift ());
+
+      g_print ("asnc(%s, %s) = %s\n",
+	       gsl_complex_str (y), gsl_complex_str (emmc),
+	       gsl_complex_str (gsl_complex_ellip_asn (y, emmc)));
+      g_print ("asn(%f, %f = %."PREC"f\n",
+	       y.re, emmc.re, gsl_ellip_asn (y.re, emmc.re));
+    }
+  else if (strcmp (arg, "sci_sn") == 0)
+    {
+      double u, k2;
+      u = atof (pshift ());
+      k2 = atof (pshift ());
+      g_print ("sci_sn(%f, %f) = %."PREC"f\n", u, k2, gsl_ellip_sn (u, 1.0 - k2));
+    }
+  else if (strcmp (arg, "sci_asn") == 0)
+    {
+      double y, k2;
+      y = atof (pshift ());
+      k2 = atof (pshift ());
+      g_print ("sci_asn(%f, %f) = %."PREC"f\n", y, k2, gsl_ellip_asn (y, 1.0 - k2));
+    }
+  else if (strcmp (arg, "sci_asnc") == 0)
+    {
+      GslComplex y, k2;
+      y.re = atof (pshift ());
+      y.im = atof (pshift ());
+      k2.re = atof (pshift ());
+      k2.im = atof (pshift ());
+      g_print ("sci_asnc(%s, %s) = %s\n",
+	       gsl_complex_str (y), gsl_complex_str (k2),
+	       gsl_complex_str (gsl_complex_ellip_asn (y, gsl_complex_sub (gsl_complex (1.0, 0), k2))));
+      g_print ("asn(%f, %f = %."PREC"f\n",
+	       y.re, k2.re, gsl_ellip_asn (y.re, 1.0 - k2.re));
+    }
+  else if (strcmp (arg, "sin") == 0)
+    {
+      GslComplex phi;
+      phi.re = atof (pshift ());
+      phi.im = atof (pshift ());
+      g_print ("sin(%s) = %s\n",
+	       gsl_complex_str (phi),
+	       gsl_complex_str (gsl_complex_sin (phi)));
+    }
+  else if (strcmp (arg, "cos") == 0)
+    {
+      GslComplex phi;
+      phi.re = atof (pshift ());
+      phi.im = atof (pshift ());
+      g_print ("cos(%s) = %s\n",
+	       gsl_complex_str (phi),
+	       gsl_complex_str (gsl_complex_cos (phi)));
+    }
+  else if (strcmp (arg, "tan") == 0)
+    {
+      GslComplex phi;
+      phi.re = atof (pshift ());
+      phi.im = atof (pshift ());
+      g_print ("tan(%s) = %s\n",
+	       gsl_complex_str (phi),
+	       gsl_complex_str (gsl_complex_tan (phi)));
+    }
+  else if (strcmp (arg, "sinh") == 0)
+    {
+      GslComplex phi;
+      phi.re = atof (pshift ());
+      phi.im = atof (pshift ());
+      g_print ("sinh(%s) = %s\n",
+	       gsl_complex_str (phi),
+	       gsl_complex_str (gsl_complex_sinh (phi)));
+    }
+  else if (strcmp (arg, "cosh") == 0)
+    {
+      GslComplex phi;
+      phi.re = atof (pshift ());
+      phi.im = atof (pshift ());
+      g_print ("cosh(%s) = %s\n",
+	       gsl_complex_str (phi),
+	       gsl_complex_str (gsl_complex_cosh (phi)));
+    }
+  else if (strcmp (arg, "tanh") == 0)
+    {
+      GslComplex phi;
+      phi.re = atof (pshift ());
+      phi.im = atof (pshift ());
+      g_print ("tanh(%s) = %s\n",
+	       gsl_complex_str (phi),
+	       gsl_complex_str (gsl_complex_tanh (phi)));
+    }
+  else if (strcmp (arg, "midi2freq") == 0)
+    {
+      gint note;
+      note = atol (pshift ());
+      note = CLAMP (note, 0, 128);
+      g_print ("midi2freq(%u) = %f\n",
+	       note,
+	       gsl_temp_freq (gsl_get_config ()->kammer_freq,
+			      note - gsl_get_config ()->midi_kammer_note));
+    }
+  else if (strcmp (arg, "blp") == 0)
+    {
+      double f, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f = atof (pshift ());
+      e = atof (pshift ());
+      f *= GSL_PI / 2.;
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+      gsl_filter_butter_lp (order, f, e, a, b);
+      g_print ("# Lowpass Butterworth filter order=%u freq=%f epsilon(s^2)=%f norm0=%f:\n",
+	       order, f, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "BL";
+    }
+  else if (strcmp (arg, "bhp") == 0)
+    {
+      double f, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f = atof (pshift ());
+      e = atof (pshift ());
+      f *= GSL_PI / 2.;
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_butter_hp (order, f, e, a, b);
+      g_print ("# Highpass Butterworth filter order=%u freq=%f epsilon(s^2)=%f norm0=%f:\n",
+	       order, f, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "BH";
+    }
+  else if (strcmp (arg, "bbp") == 0)
+    {
+      double f1, f2, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f1 = atof (pshift ());
+      f2 = atof (pshift ());
+      e = atof (pshift ());
+      f1 *= GSL_PI / 2.;
+      f2 *= GSL_PI / 2.;
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_butter_bp (order, f1, f2, e, a, b);
+      g_print ("# Bandpass Butterworth filter order=%u freq1=%f freq2=%f epsilon(s^2)=%f norm0=%f:\n",
+	       order, f1, f2, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "BP";
+    }
+  else if (strcmp (arg, "bbs") == 0)
+    {
+      double f1, f2, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f1 = atof (pshift ());
+      f2 = atof (pshift ());
+      e = atof (pshift ());
+      f1 *= GSL_PI / 2.;
+      f2 *= GSL_PI / 2.;
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_butter_bs (order, f1, f2, e, a, b);
+      g_print ("# Bandstop Butterworth filter order=%u freq1=%f freq2=%f epsilon(s^2)=%f norm0=%f:\n",
+	       order, f1, f2, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "BS";
+    }
+  else if (strcmp (arg, "t1l") == 0)
+    {
+      double f, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f = atof (pshift ());
+      e = atof (pshift ());
+      f *= GSL_PI / 2.;
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_tscheb1_lp (order, f, e, a, b);
+      g_print ("# Lowpass Tschebyscheff Type1 order=%u freq=%f epsilon(s^2)=%f norm0=%f:\n",
+	       order, f, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "T1L";
+    }
+  else if (strcmp (arg, "t1h") == 0)
+    {
+      double f, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f = atof (pshift ());
+      e = atof (pshift ());
+      f *= GSL_PI / 2.;
+
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_tscheb1_hp (order, f, e, a, b);
+      g_print ("# Highpass Tschebyscheff Type1 order=%u freq=%f epsilon(s^2)=%f norm0=%f:\n",
+	       order, f, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "T1H";
+    }
+  else if (strcmp (arg, "t1s") == 0)
+    {
+      double fc, fr, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      fc = atof (pshift ());
+      fr = atof (pshift ());
+      e = atof (pshift ());
+      fc *= GSL_PI / 2.;
+      fr *= GSL_PI / 2.;
+
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_tscheb1_bs (order, fc, fr, e, a, b);
+      g_print ("# Bandstop Tschebyscheff Type1 order=%u freq_c=%f freq_r=%f epsilon(s^2)=%f norm=%f:\n",
+	       order, fc, fr, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "T1S";
+    }
+  else if (strcmp (arg, "t1p") == 0)
+    {
+      double fc, fr, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      fc = atof (pshift ());
+      fr = atof (pshift ());
+      e = atof (pshift ());
+      fc *= GSL_PI / 2.;
+      fr *= GSL_PI / 2.;
+
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_tscheb1_bp (order, fc, fr, e, a, b);
+      g_print ("# Bandpass Tschebyscheff Type1 order=%u freq_c=%f freq_r=%f epsilon(s^2)=%f norm=%f:\n",
+	       order, fc, fr, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "T1P";
+    }
+  else if (strcmp (arg, "t2l") == 0)
+    {
+      double f, st, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f = atof (pshift ());
+      st = atof (pshift ());
+      e = atof (pshift ());
+      f *= GSL_PI / 2.;
+
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_tscheb2_lp (order, f, st, e, a, b);
+      g_print ("# Lowpass Tschebyscheff Type2 order=%u freq=%f steepness=%f (%f) epsilon(s^2)=%f norm=%f:\n",
+	       order, f, st, f * (1.+st), e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "T2L";
+    }
+  else if (strcmp (arg, "t2h") == 0)
+    {
+      double f, st, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f = atof (pshift ());
+      st = atof (pshift ());
+      e = atof (pshift ());
+      f *= GSL_PI / 2.;
+
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_tscheb2_hp (order, f, st, e, a, b);
+      g_print ("# Highpass Tschebyscheff Type2 order=%u freq=%f steepness=%f (%f, %f) epsilon(s^2)=%f norm=%f:\n",
+	       order, f, st, GSL_PI - f, (GSL_PI - f) * (1.+st), e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "T2H";
+    }
+  else if (strcmp (arg, "t2p") == 0)
+    {
+      double f1, f2, st, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f1 = atof (pshift ());
+      f2 = atof (pshift ());
+      st = atof (pshift ());
+      e = atof (pshift ());
+      f1 *= GSL_PI / 2.;
+      f2 *= GSL_PI / 2.;
+
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_tscheb2_bp (order, f1, f2, st, e, a, b);
+      g_print ("# Bandpass Tschebyscheff Type2 order=%u freq1=%f freq2=%f steepness=%f epsilon(s^2)=%f norm=%f:\n",
+	       order, f1, f2, st, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "T2P";
+    }
+  else if (strcmp (arg, "t2s") == 0)
+    {
+      double f1, f2, st, e;
+      order = atoi (pshift ()); order = MAX (order, 1);
+      f1 = atof (pshift ());
+      f2 = atof (pshift ());
+      st = atof (pshift ());
+      e = atof (pshift ());
+      f1 *= GSL_PI / 2.;
+      f2 *= GSL_PI / 2.;
+
+      a = g_new (gdouble, order + 1);
+      b = g_new (gdouble, order + 1);
+
+      gsl_filter_tscheb2_bs (order, f1, f2, st, e, a, b);
+      g_print ("# Bandstop Tschebyscheff Type2 order=%u freq1=%f freq2=%f steepness=%f epsilon(s^2)=%f norm=%f:\n",
+	       order, f1, f2, st, e,
+	       gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+      filter_label = "T2S";
+    }
+  else if (strcmp (arg, "scan") == 0)
+    {
+      filter_mode = FILTER_SCAN;
+    }
+  else if (strcmp (arg, "fir") == 0)
+    {
+      unsigned int iorder = atoi (pshift ());
+      unsigned int n_points = 0;
+
+      double *freq = g_newa (double, argc / 2 + 1);
+      double *value = g_newa (double, argc / 2 + 1);
+      double *a = g_newa (double, iorder);
+      const char *f, *v;
+
+      do
+	{
+	  f = pshift ();
+	  v = pshift ();
+
+	  if (f[0] && v[0])
+	    {
+	      freq[n_points] = atof (f) * GSL_PI;
+	      value[n_points] = atof (v);
+	      n_points++;
+	    }
+	}
+      while (f[0] && v[0]);
+
+      gsl_filter_fir_approx (iorder, a, n_points, freq, value);
+      g_print ("FIR%u(z)=%s\n", iorder, gsl_poly_str (iorder, a, "z"));
+    }
+  else if (strncmp (arg, "poly", 4) == 0)
+    {
+      guint order;
+      arg = arg + 4;
+      order = 2;
+      {
+	double a[100] = { 1, 2, 1 }, b[100] = { 1, -3./2., 0.5 };
+	g_print ("# Test order=%u  norm=%f:\n",
+		 order,
+		 gsl_poly_eval (order, a, 1) / gsl_poly_eval (order, b, 1));
+	g_print ("H%u(z)=%s/%s\n", order,
+		 gsl_poly_str (order, a, "z"),
+		 gsl_poly_str (order, b, "z"));
+	if (*arg)
+	  {
+	    GslComplex root, roots[100];
+	    guint i;
+
+	    if (*arg == 'r')
+	      {
+		g_print ("#roots:\n");
+		gsl_poly_complex_roots (order, a, roots);
+		for (i = 0; i < order; i++)
+		  {
+		    root = gsl_complex_div (gsl_complex (1, 0), roots[i]);
+		    g_print ("%+.14f %+.14f # %.14f\n", root.re, root.im, gsl_complex_abs (root));
+		  }
+	      }
+	    if (*arg == 'p')
+	      {
+		g_print ("#poles:\n");
+		gsl_poly_complex_roots (order, b, roots);
+		for (i = 0; i < order; i++)
+		  {
+		    root = gsl_complex_div (gsl_complex (1, 0), roots[i]);
+		    g_print ("%+.14f %+.14f # %.14f\n", root.re, root.im, gsl_complex_abs (root));
+		  }
+	      }
+	  }
+      }
+    }
+  else
+    usage ();
+
+  if (a && b)
+    {
+      gdouble freq;
+
+      if (filter_mode == FILTER_SCAN)
+	{
+	  freq = 0.001;
+	  while (freq < 3.14)
+	    {
+	      g_print ("%f %.20f\n", freq, gsl_filter_sine_scan (order, a, b, freq, MAX((int)(1000.0/freq),10000)));
+	      freq = MIN (freq * 1.1, freq + 0.01);
+	    }
+	}
+      else if (filter_mode == FILTER_GNUPLOT)
+	{
+	  g_print ("%s%u(z)=%s/%s\n", filter_label, order,
+		   gsl_poly_str (order, a, "z"),
+		   gsl_poly_str (order, b, "z"));
+	}
+      else
+	g_error ("unknown filter_mode");
+      g_free (a);
+      g_free (b);
+    }
+
+  arg = shift ();
+  if (arg)
+    goto restart;
+
+  return 0;
+}
+
+static void
+usage (void)
+{
+  g_print ("usage: gsltests {test} [args...]\n");
+  g_print ("tests:\n");
+  g_print ("  wave-scan <file>          scan a wave file for waves\n");
+  g_print ("  file-test <file>          test file properties\n");
+  g_print ("  rf <x> <y> <z>            Carlson's elliptic integral of the first kind\n");
+  g_print ("  F <phi> <ak>              Legendre elliptic integral of the 1st kind\n");
+  g_print ("  sn <u> <emmc>             Jacobian elliptic function sn()\n");
+  g_print ("  asn <y> <emmc>            elliptic integral, inverse sn()\n");
+  g_print ("  sin <phi.re> <phi.im>     complex sine\n");
+  g_print ("  cos <phi.re> <phi.im>     complex cosine\n");
+  g_print ("  tan <phi.re> <phi.im>     complex tangent\n");
+  g_print ("  sinh <phi.re> <phi.im>    complex hyperbolic sine\n");
+  g_print ("  cosh <phi.re> <phi.im>    complex hyperbolic cosine\n");
+  g_print ("  tanh <phi.re> <phi.im>    complex hyperbolic tangent\n");
+  g_print ("  midi2freq <midinote>      convert midinote into oscilaltor frequency\n");
+  g_print ("  snc <u.re> <u.im> <emmc.re> <emmc.im>     sn() for complex numbers\n");
+  g_print ("  asnc <y.re> <y.im> <emmc.re> <emmc.im>    asn() for complex numbers\n");
+  g_print ("  sci_sn <u> <k2>                           scilab version of sn()\n");
+  g_print ("  sci_asn <y> <k2>                          scilab version of asn()\n");
+  g_print ("  sci_snc <u.re> <u.im> <k2.re> <k2.im>     scilab version of snc()\n");
+  g_print ("  sci_asnc <y.re> <y.im> <k2.re> <k2.im>    scilab version of asnc()\n");
+  g_print ("  blp <order> <freq> <epsilon>              butterworth lowpass filter\n");
+  g_print ("  bhp <order> <freq> <epsilon>              butterworth higpass filter\n");
+  g_print ("  bbp <order> <freqc> <freqr> <epsilon>     butterworth bandpass filter\n");
+  g_print ("  t1l <order> <freq> <epsilon>              type1 tschebyscheff lowpass filter\n");
+  g_print ("  t1h <order> <freq> <epsilon>              type1 tschebyscheff highpass filter\n");
+  g_print ("  t1s <order> <freqc> <freqr> <epsilon>     type1 tschebyscheff bandstop filter\n");
+  g_print ("  t1p <order> <freqc> <freqr> <epsilon>     type1 tschebyscheff bandpass filter\n");
+  g_print ("  t2l <order> <freqc> <steepn> <epsilon>    type2 tschebyscheff lowpass filter\n");
+  g_print ("  t2h <order> <freqc> <steepn> <epsilon>    type2 tschebyscheff highpass filter\n");
+  g_print ("  fir <order> <freq1> <value1> ...          fir approximation\n");
+  g_print ("  scan blp <order> <freq> <epsilon>         scan butterworth lowpass filter\n");
+  g_print ("  poly | polyr | polyp                      polynom test (+roots or +poles)\n");
+  exit (1);
+}
+
+
+
+/* vim:set ts=8 sts=2 sw=2: */
diff --git a/flow/gsl/gslwave.header b/flow/gsl/gslwave.header
new file mode 100644
index 0000000..2b0bf5b
--- /dev/null
+++ b/flow/gsl/gslwave.header
diff --git a/flow/gsl/gslwavechunk.c b/flow/gsl/gslwavechunk.c
new file mode 100644
index 0000000..06a105f
--- /dev/null
+++ b/flow/gsl/gslwavechunk.c
@@ -0,0 +1,812 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslwavechunk.h"
+
+#include "gslcommon.h"
+#include "gsldatahandle.h"
+
+#include <string.h>
+
+
+/* --- macros --- */
+#define	PRINT_DEBUG_INFO		(0)
+#define	STATIC_ZERO_SIZE		(4096)
+#define	PBLOCK_SIZE(pad, n_channels)	(MAX (2 * (pad), (n_channels) * gsl_get_config ()->wave_chunk_big_pad))
+
+#define	PHASE_NORM(wchunk)		((GslWaveChunkMem*) (0))
+#define	PHASE_NORM_BACKWARD(wchunk)	((GslWaveChunkMem*) (+1))
+#define	PHASE_UNDEF(wchunk)		((GslWaveChunkMem*) (+2))
+#define	PHASE_HEAD(wchunk)		(&(wchunk)->head)
+#define	PHASE_ENTER(wchunk)		(&(wchunk)->enter)
+#define	PHASE_WRAP(wchunk)		(&(wchunk)->wrap)
+#define	PHASE_PPWRAP(wchunk)		(&(wchunk)->ppwrap)
+#define	PHASE_LEAVE(wchunk)		(&(wchunk)->leave)
+#define	PHASE_TAIL(wchunk)		(&(wchunk)->tail)
+
+
+/* --- typedefs & structures --- */
+typedef struct {
+  GslLong pos;			/* input */
+  GslLong rel_pos;
+  GslLong lbound, ubound;	/* PHASE_NORM/_BACKWARD */
+} Iter;
+typedef struct {
+  GslLong dir;
+  GslLong pos;
+  GslLong loop_count;
+} WPos;
+
+
+/* --- variables --- */
+static gfloat static_zero_block[STATIC_ZERO_SIZE] = { 0, };	/* FIXME */
+
+
+/* --- functions --- */
+static inline void
+wpos_step (GslWaveChunk *wchunk,
+	   WPos         *wpos)
+{
+  wpos->pos += wpos->dir;
+  if (wpos->loop_count)
+    {
+      if (wchunk->loop_type == GSL_WAVE_LOOP_PINGPONG)
+	{
+	  if (wpos->dir < 0 &&
+	      wpos->pos == wchunk->loop_first + wpos->dir)
+	    {
+	      wpos->loop_count--;
+	      wpos->dir = -wpos->dir;
+	      wpos->pos = wchunk->loop_first + wpos->dir;
+	    }
+	  else if (wpos->pos == wchunk->loop_last + wpos->dir)
+	    {
+	      wpos->loop_count--;
+	      wpos->dir = -wpos->dir;
+	      wpos->pos = wchunk->loop_last + wpos->dir;
+	    }
+	}
+      else
+	{
+	  if (wpos->pos == wchunk->loop_last + wpos->dir && wpos->loop_count)
+	    {
+	      wpos->loop_count--;
+	      wpos->pos = wchunk->loop_first;
+	    }
+	}
+    }
+}
+
+static void
+fill_block (GslWaveChunk *wchunk,
+	    gfloat	 *block,
+	    GslLong	  offset,
+	    guint	  length,
+	    gboolean	  backward,
+	    guint	  loop_count)
+{
+  GslLong dcache_length = gsl_data_handle_length (wchunk->dcache->dhandle);
+  guint i, dnode_length = wchunk->dcache->node_size;
+  GslDataCacheNode *dnode;
+  WPos wpos;
+
+  wpos.dir = wchunk->n_channels;
+  if (backward)
+    wpos.dir = -wpos.dir;
+  wpos.pos = offset;
+  wpos.loop_count = loop_count;
+  dnode = gsl_data_cache_ref_node (wchunk->dcache, 0, TRUE);
+  for (i = 0; i < length; i++)
+    {
+      GslLong offset = wpos.pos;
+
+      if (offset < 0 || offset >= dcache_length)
+	block[i] = 0;
+      else
+	{
+	  if (offset < dnode->offset || offset >= dnode->offset + dnode_length)
+	    {
+	      gsl_data_cache_unref_node (wchunk->dcache, dnode);
+	      dnode = gsl_data_cache_ref_node (wchunk->dcache, offset, TRUE);
+	    }
+	  block[i] = dnode->data[offset - dnode->offset];
+	}
+      wpos_step (wchunk, &wpos);
+    }
+  gsl_data_cache_unref_node (wchunk->dcache, dnode);
+}
+
+static gfloat*
+create_block_for_offset (GslWaveChunk *wchunk,
+			 GslLong       offset,
+			 guint         length)
+{
+  GslLong padding = wchunk->n_pad_values;
+  GslLong one = wchunk->n_channels;
+  GslLong wave_last = wchunk->length - one;
+  GslLong loop_width = wchunk->loop_last - wchunk->loop_first;
+  gfloat *mem;
+  GslLong l, j, k;
+
+  if (wchunk->loop_type != GSL_WAVE_LOOP_PINGPONG)
+    loop_width += one;
+
+  l = length + 2 * padding;
+  mem = gsl_new_struct (gfloat, l);
+  offset -= padding;
+  j = ((wchunk->wave_length - one - offset) -
+       (wchunk->pploop_ends_backwards ? wchunk->loop_first : wave_last - wchunk->loop_last));
+  if (j >= 0)
+    {
+      k = j / loop_width;
+      /* g_print ("endoffset-setup: j=%ld %%=%ld, k=%ld, k&1=%ld\n", j, j % loop_width, k, k & 1); */
+      j %= loop_width;
+      if (wchunk->loop_type == GSL_WAVE_LOOP_PINGPONG)
+	{
+	  if (wchunk->pploop_ends_backwards && (k & 1))
+	    fill_block (wchunk, mem, wchunk->loop_last - j, l, FALSE, k);
+	  else if (wchunk->pploop_ends_backwards)
+	    fill_block (wchunk, mem, wchunk->loop_first + j, l, TRUE, k);
+	  else if (k & 1)
+	    fill_block (wchunk, mem, wchunk->loop_first + j, l, TRUE, k);
+	  else
+	    fill_block (wchunk, mem, wchunk->loop_last - j, l, FALSE, k);
+	}
+      else
+	fill_block (wchunk, mem, wchunk->loop_last - j, l, FALSE, k);
+    }
+  else if (wchunk->pploop_ends_backwards)
+    fill_block (wchunk, mem, wchunk->loop_first + j, l, TRUE, 0);
+  else
+    fill_block (wchunk, mem, wchunk->loop_last - j, l, FALSE, 0);
+  return mem + padding;
+}
+
+static void
+setup_pblocks (GslWaveChunk *wchunk)
+{
+  GslLong padding = wchunk->n_pad_values;
+  GslLong big_pad = PBLOCK_SIZE (wchunk->n_pad_values, wchunk->n_channels);
+  GslLong loop_width = wchunk->loop_last - wchunk->loop_first;
+  GslLong one = wchunk->n_channels;
+  GslLong loop_duration, wave_last = wchunk->length - one;
+  gfloat *mem;
+  guint l;
+
+  if (wchunk->loop_type != GSL_WAVE_LOOP_PINGPONG)
+    loop_width += one;
+  loop_duration = loop_width * wchunk->loop_count;
+
+  wchunk->head.start = -padding;
+  wchunk->head.end = big_pad;
+  wchunk->head.length = wchunk->head.end - wchunk->head.start + one;
+  wchunk->tail_start_norm = wave_last - big_pad;
+  wchunk->tail.start = wchunk->tail_start_norm + loop_duration;
+  wchunk->tail.end = wchunk->tail.start + big_pad + padding;
+  wchunk->tail.length = wchunk->tail.end - wchunk->tail.start + one;
+  if (wchunk->loop_type)
+    {
+      wchunk->enter.start = wchunk->loop_last - padding;
+      wchunk->enter.end = wchunk->loop_last + one + big_pad;
+      wchunk->wrap.start = loop_width - padding;
+      wchunk->wrap.end = big_pad;
+      if (wchunk->loop_type == GSL_WAVE_LOOP_PINGPONG)
+	{
+	  wchunk->enter.end -= one;
+	  wchunk->wrap.end -= one;
+	  wchunk->ppwrap.start = wchunk->wrap.start;
+	  wchunk->ppwrap.end = wchunk->wrap.end + loop_width;
+	  wchunk->ppwrap.length = wchunk->ppwrap.end - wchunk->ppwrap.start + one;
+	  wchunk->wrap.length = loop_width - wchunk->wrap.start + wchunk->wrap.end + one;
+	  wchunk->wrap.start += loop_width;
+	}
+      else
+	wchunk->wrap.length = loop_width - wchunk->wrap.start + wchunk->wrap.end + one;
+      wchunk->leave_end_norm = wchunk->loop_last + big_pad;
+      wchunk->leave.start = wchunk->loop_last + loop_duration - padding;
+      wchunk->leave.end = wchunk->leave_end_norm + loop_duration;
+      if (wchunk->mini_loop)
+	{
+	  wchunk->leave.start -= wchunk->wrap.length + padding;
+	  wchunk->enter.end += wchunk->wrap.length + padding;
+	}
+      wchunk->leave.length = wchunk->leave.end - wchunk->leave.start + one;
+      wchunk->enter.length = wchunk->enter.end - wchunk->enter.start + one;
+      if (wchunk->pploop_ends_backwards)
+	{
+	  wchunk->tail.start += wchunk->loop_last - wave_last + wchunk->loop_first;
+	  wchunk->tail.end += wchunk->loop_last - wave_last + wchunk->loop_first;
+	  wchunk->tail_start_norm = 0 + big_pad;
+	  wchunk->leave_end_norm = wchunk->loop_first - big_pad;
+	}
+    }
+  else
+    {
+      /*
+      wchunk->enter.start = wchunk->head.end;
+      wchunk->enter.end = wchunk->head.end;
+      wchunk->enter.length = 0;
+      */
+      wchunk->enter.start = wchunk->tail.start;
+      wchunk->enter.end = wchunk->head.end;
+      wchunk->enter.length = 0;
+      wchunk->wrap.start = wchunk->tail.end + 1;
+      wchunk->wrap.end = wchunk->head.start - 1;
+      wchunk->wrap.length = 0;
+      wchunk->ppwrap.start = wchunk->tail.end + 1;
+      wchunk->ppwrap.end = wchunk->head.start - 1;
+      wchunk->ppwrap.length = 0;
+      wchunk->leave.start = wchunk->tail.start;
+      wchunk->leave.end = wchunk->tail.end;
+      wchunk->leave_end_norm = 0;
+      wchunk->leave.length = 0;
+    }
+
+  l = wchunk->head.length + 2 * padding;
+  mem = gsl_new_struct (gfloat, l);
+  fill_block (wchunk, mem, wchunk->head.start - padding, l, FALSE, wchunk->loop_count);
+  wchunk->head.mem = mem + padding;
+  if (wchunk->loop_type)
+    {
+      l = wchunk->enter.length + 2 * padding;
+      mem = gsl_new_struct (gfloat, l);
+      fill_block (wchunk, mem, wchunk->enter.start - padding, l, FALSE, wchunk->loop_count);
+      wchunk->enter.mem = mem + padding;
+      if (wchunk->loop_type == GSL_WAVE_LOOP_PINGPONG)
+	{
+	  wchunk->wrap.mem = create_block_for_offset (wchunk, wchunk->loop_last + one + wchunk->wrap.start, wchunk->wrap.length);
+	  wchunk->ppwrap.mem = create_block_for_offset (wchunk, wchunk->loop_last + one + wchunk->ppwrap.start, wchunk->ppwrap.length);
+	}
+      else
+	{
+	  l = wchunk->wrap.length + 2 * padding;
+	  mem = gsl_new_struct (gfloat, l);
+	  fill_block (wchunk, mem, wchunk->loop_first + wchunk->wrap.start - padding, l, FALSE, wchunk->loop_count - 1);
+	  wchunk->wrap.mem = mem + padding;
+	}
+      wchunk->leave.mem = create_block_for_offset (wchunk, wchunk->leave.start, wchunk->leave.length);
+    }
+  wchunk->tail.mem = create_block_for_offset (wchunk, wchunk->tail.start, wchunk->tail.length);
+}
+
+static inline GslWaveChunkMem*
+wave_identify_offset (GslWaveChunk *wchunk,
+		      Iter         *iter)
+{
+  GslLong pos = iter->pos;
+  GslLong one = wchunk->n_channels;
+
+  if (pos < wchunk->head.start)					/* outside wave boundaries */
+    {
+      iter->lbound = 0;
+      iter->rel_pos = wchunk->n_pad_values;
+      iter->ubound = iter->rel_pos + MIN (STATIC_ZERO_SIZE - 2 * wchunk->n_pad_values, wchunk->head.start - pos);
+      if (PRINT_DEBUG_INFO)
+	g_print ("PHASE_UNDEF, pre-head %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+      return PHASE_UNDEF (wchunk);
+    }
+  if (pos > wchunk->tail.end)					/* outside wave boundaries */
+    {
+      iter->lbound = 0;
+      iter->rel_pos = wchunk->n_pad_values;
+      iter->ubound = iter->rel_pos + MIN (STATIC_ZERO_SIZE - 2 * wchunk->n_pad_values, pos - wchunk->tail.end);
+      if (PRINT_DEBUG_INFO)
+	g_print ("PHASE_UNDEF, post-tail %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+      return PHASE_UNDEF (wchunk);
+    }
+  if (pos <= wchunk->head.end)
+    {
+      iter->rel_pos = pos - wchunk->head.start;
+      if (PRINT_DEBUG_INFO)
+	g_print ("PHASE_HEAD %ld %ld %ld\n", wchunk->head.start, iter->rel_pos, wchunk->head.end);
+      return PHASE_HEAD (wchunk);
+    }
+  else if (pos <= wchunk->enter.end)					/* before loop */
+    {
+      if (pos >= wchunk->enter.start)
+	{
+	  iter->rel_pos = pos - wchunk->enter.start;
+	  if (PRINT_DEBUG_INFO)
+	    g_print ("PHASE_ENTER %ld %ld %ld\n", wchunk->enter.start, iter->rel_pos, wchunk->enter.end);
+	  return PHASE_ENTER (wchunk);
+	}
+      iter->rel_pos = pos - wchunk->head.end;
+      iter->lbound = wchunk->head.end;
+      iter->ubound = wchunk->enter.start;
+      if (PRINT_DEBUG_INFO)
+	g_print ("PHASE_NORM, pre-enter %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+      return PHASE_NORM (wchunk);
+    }
+  else if (pos >= wchunk->tail.start)
+    {
+      iter->rel_pos = pos - wchunk->tail.start;
+      if (PRINT_DEBUG_INFO)
+	g_print ("PHASE_TAIL %ld %ld %ld\n", wchunk->tail.start, iter->rel_pos, wchunk->tail.end);
+      return PHASE_TAIL (wchunk);
+    }
+  else if (pos >= wchunk->leave.start)				/* after loop */
+    {
+      if (pos <= wchunk->leave.end)
+	{
+	  iter->rel_pos = pos - wchunk->leave.start;
+	  if (PRINT_DEBUG_INFO)
+	    g_print ("PHASE_LEAVE %ld %ld %ld\n", wchunk->leave.start, iter->rel_pos, wchunk->leave.end);
+	  return PHASE_LEAVE (wchunk);
+	}
+      iter->rel_pos = pos - wchunk->leave.end;
+      if (wchunk->pploop_ends_backwards)
+	{
+	  iter->lbound = wchunk->tail_start_norm;
+	  iter->ubound = wchunk->leave_end_norm;
+	  if (PRINT_DEBUG_INFO)
+	    g_print ("PHASE_NORM_BACKWARD, post-leave %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+	  return PHASE_NORM_BACKWARD (wchunk);
+	}
+      else
+	{
+	  iter->lbound = wchunk->leave_end_norm;
+	  iter->ubound = wchunk->tail_start_norm;
+	  if (PRINT_DEBUG_INFO)
+	    g_print ("PHASE_NORM, post-leave %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+	  return PHASE_NORM (wchunk);
+	}
+    }
+  else if (wchunk->loop_type == GSL_WAVE_LOOP_PINGPONG)		/* in ping-pong loop */
+    {
+      guint loop_width = wchunk->loop_last - wchunk->loop_first;
+
+      pos -= wchunk->loop_last + one;
+      pos %= 2 * loop_width;
+      if (pos <= wchunk->ppwrap.end)
+	{
+	  if (pos <= wchunk->wrap.end)
+	    {
+	      iter->rel_pos = wchunk->wrap.length - one - wchunk->wrap.end + pos;
+	      if (PRINT_DEBUG_INFO)
+		g_print ("PHASE_WRAP %ld %ld %ld\n", wchunk->wrap.start, iter->rel_pos, wchunk->wrap.end);
+	      return PHASE_WRAP (wchunk);
+	    }
+	  if (pos >= wchunk->ppwrap.start)
+	    {
+	      iter->rel_pos = pos - wchunk->ppwrap.start;
+	      if (PRINT_DEBUG_INFO)
+		g_print ("PHASE_PPWRAP %ld %ld %ld\n", wchunk->ppwrap.start, iter->rel_pos, wchunk->ppwrap.end);
+	      return PHASE_PPWRAP (wchunk);
+	    }
+	  iter->ubound = wchunk->loop_last - one - wchunk->wrap.end;
+	  iter->lbound = wchunk->loop_last - one - wchunk->ppwrap.start;
+	  iter->rel_pos = pos - wchunk->wrap.end;
+	  if (PRINT_DEBUG_INFO)
+	    g_print ("PHASE_NORM_BACKWARD, pploop %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+	  return PHASE_NORM_BACKWARD (wchunk);
+	}
+      if (pos >= wchunk->wrap.start)
+	{
+	  iter->rel_pos = pos - wchunk->wrap.start;
+	  if (PRINT_DEBUG_INFO)
+	    g_print ("PHASE_WRAP %ld %ld %ld\n", wchunk->wrap.start, iter->rel_pos, wchunk->wrap.end);
+	  return PHASE_WRAP (wchunk);
+	}
+      iter->rel_pos = pos - wchunk->ppwrap.end;
+      iter->ubound = wchunk->loop_first + one + wchunk->wrap.start - loop_width;
+      iter->lbound = wchunk->loop_first + one + wchunk->ppwrap.end - loop_width;
+      if (PRINT_DEBUG_INFO)
+	g_print ("PHASE_NORM, pploop %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+      return PHASE_NORM (wchunk);
+    }
+  else if (wchunk->loop_type == GSL_WAVE_LOOP_JUMP)		/* in jump loop */
+    {
+      guint loop_width = wchunk->loop_last - wchunk->loop_first + one;
+
+      pos -= wchunk->loop_last + one;
+      pos %= loop_width;
+      if (pos >= wchunk->wrap.start)
+	{
+	  iter->rel_pos = pos - wchunk->wrap.start;
+	  if (PRINT_DEBUG_INFO)
+	    g_print ("PHASE_WRAP %ld %ld %ld\n", wchunk->wrap.start, iter->rel_pos, wchunk->wrap.end);
+	  return PHASE_WRAP (wchunk);
+	}
+      if (pos <= wchunk->wrap.end)
+	{
+	  iter->rel_pos = wchunk->wrap.length - one - wchunk->wrap.end + pos;
+	  if (PRINT_DEBUG_INFO)
+	    g_print ("PHASE_WRAP %ld %ld %ld\n", wchunk->wrap.start, iter->rel_pos, wchunk->wrap.end);
+	  return PHASE_WRAP (wchunk);
+	}
+      iter->rel_pos = pos - wchunk->wrap.end;
+      iter->lbound = wchunk->loop_first + wchunk->wrap.end;
+      iter->ubound = wchunk->loop_first + wchunk->wrap.start;
+      if (PRINT_DEBUG_INFO)
+	g_print ("PHASE_NORM, jloop %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+      return PHASE_NORM (wchunk);
+    }
+  iter->rel_pos = pos - wchunk->head.end;
+  iter->lbound = wchunk->head.end;
+  iter->ubound = wchunk->enter.start;
+  if (PRINT_DEBUG_INFO)
+    g_print ("PHASE_NORM, noloop %ld %ld %ld\n", iter->lbound, iter->rel_pos, iter->ubound);
+  return PHASE_NORM (wchunk);
+}
+
+void
+gsl_wave_chunk_use_block (GslWaveChunk      *wchunk,
+			  GslWaveChunkBlock *block)
+{
+  GslWaveChunkMem *phase;
+  GslLong one;
+  Iter iter;
+  gboolean reverse;
+
+  g_return_if_fail (wchunk != NULL);
+  g_return_if_fail (wchunk->open_count > 0);
+  g_return_if_fail (block != NULL);
+  g_return_if_fail (wchunk->dcache != NULL);
+  g_return_if_fail (block->node == NULL);
+  g_return_if_fail (block->play_dir == -1 || block->play_dir == +1);
+
+  block->offset /= wchunk->n_channels;
+  block->offset *= wchunk->n_channels;
+
+  one = wchunk->n_channels;
+  reverse = block->play_dir < 0;
+  iter.pos = block->offset;
+  phase = wave_identify_offset (wchunk, &iter);
+
+  block->is_silent = FALSE;
+  if (phase <= PHASE_UNDEF (wchunk))
+    {
+      GslDataCacheNode *dnode;
+      guint offset;
+
+      if (phase == PHASE_UNDEF (wchunk))
+	{
+	  block->is_silent = TRUE;
+	  reverse = FALSE;
+	  block->length = (iter.ubound - iter.rel_pos) / wchunk->n_channels;
+	  block->length *= wchunk->n_channels;
+	  g_assert (block->length <= STATIC_ZERO_SIZE - 2 * wchunk->n_pad_values);
+	  block->start = static_zero_block + iter.rel_pos;
+	}
+      else
+	{
+	  GslLong max_length;
+
+	  if (phase == PHASE_NORM_BACKWARD (wchunk))
+	    {
+	      offset = iter.ubound - iter.rel_pos;
+	      reverse = !reverse;
+	    }
+	  else
+	    offset = iter.lbound + iter.rel_pos;
+	  max_length = reverse ? offset - iter.lbound : iter.ubound - offset;
+	  dnode = gsl_data_cache_ref_node (wchunk->dcache, offset, TRUE); /* FIXME: demand_load */
+	  offset -= dnode->offset;
+	  block->start = dnode->data + offset;
+	  if (reverse)
+	    {
+	      block->length = 1 + offset / wchunk->n_channels;
+	      block->length *= wchunk->n_channels;
+	    }
+	  else
+	    {
+	      block->length = (wchunk->dcache->node_size - offset) / wchunk->n_channels;
+	      block->length *= wchunk->n_channels;
+	    }
+	  block->length = MIN (block->length, max_length);
+	  block->node = dnode;
+	}
+    }
+  else
+    {
+      block->start = phase->mem + iter.rel_pos;
+      if (reverse)
+	block->length = one + iter.rel_pos;
+      else
+	block->length = phase->length - iter.rel_pos;
+    }
+  if (reverse)
+    {
+      block->dirstride = -wchunk->n_channels;
+      block->end = block->start - block->length;
+    }
+  else
+    {
+      block->dirstride = +wchunk->n_channels;
+      block->end = block->start + block->length;
+    }
+  g_assert (block->length > 0);
+  /* we might want to partly reset this at some point to implement
+   * truly infinite loops
+   */
+  block->next_offset = block->offset + (block->play_dir > 0 ? block->length : -block->length);
+}
+
+void
+gsl_wave_chunk_unuse_block (GslWaveChunk      *wchunk,
+			    GslWaveChunkBlock *block)
+{
+  g_return_if_fail (wchunk != NULL);
+  g_return_if_fail (block != NULL);
+  g_return_if_fail (wchunk->dcache != NULL);
+
+  if (block->node)
+    {
+      gsl_data_cache_unref_node (wchunk->dcache, block->node);
+      block->node = NULL;
+    }
+}
+
+static void
+wave_chunk_setup_loop (GslWaveChunk *wchunk)
+{
+  GslWaveLoopType loop_type = wchunk->requested_loop_type;
+  GslLong loop_first = wchunk->requested_loop_first;
+  GslLong loop_last = wchunk->requested_loop_last;
+  guint loop_count = wchunk->requested_loop_count;
+  GslLong one, padding, big_pad;
+
+  g_return_if_fail (wchunk->open_count > 0);
+
+  one = wchunk->n_channels;
+  padding = wchunk->n_pad_values;
+  big_pad = PBLOCK_SIZE (wchunk->n_pad_values, wchunk->n_channels);
+
+  /* check validity */
+  if (loop_count < 1 || loop_first < 0 || loop_last < 0 || wchunk->length < 1)
+    loop_type = GSL_WAVE_LOOP_NONE;
+
+  /* setup loop types */
+  switch (loop_type)
+    {
+    case GSL_WAVE_LOOP_JUMP:
+      loop_first /= wchunk->n_channels;
+      loop_last /= wchunk->n_channels;
+      if (loop_last >= wchunk->length ||
+	  loop_first >= loop_last)
+	goto CASE_DONT_LOOP;
+      wchunk->loop_type = loop_type;
+      wchunk->loop_first = loop_first * wchunk->n_channels;
+      wchunk->loop_last = loop_last * wchunk->n_channels;
+      wchunk->loop_count = (G_MAXINT - wchunk->length) / (wchunk->loop_last - wchunk->loop_first + one);
+      wchunk->loop_count = MIN (wchunk->loop_count, loop_count);
+      wchunk->wave_length = wchunk->length + (wchunk->loop_last - wchunk->loop_first + one) * wchunk->loop_count;
+      break;
+    case GSL_WAVE_LOOP_PINGPONG:
+      loop_first /= wchunk->n_channels;
+      loop_last /= wchunk->n_channels;
+      if (loop_last >= wchunk->length ||
+	  loop_first >= loop_last)
+	goto CASE_DONT_LOOP;
+      wchunk->loop_type = loop_type;
+      wchunk->loop_first = loop_first * wchunk->n_channels;
+      wchunk->loop_last = loop_last * wchunk->n_channels;
+      wchunk->loop_count = (G_MAXINT - wchunk->loop_last - one) / (wchunk->loop_last - wchunk->loop_first);
+      wchunk->loop_count = MIN (wchunk->loop_count, loop_count);
+      wchunk->wave_length = wchunk->loop_last + one + (wchunk->loop_last - wchunk->loop_first) * wchunk->loop_count;
+      if (wchunk->loop_count & 1)	/* FIXME */
+	wchunk->wave_length += wchunk->loop_first;
+      else
+	wchunk->wave_length += wchunk->length - one - wchunk->loop_last;
+      break;
+    CASE_DONT_LOOP:
+      loop_type = GSL_WAVE_LOOP_NONE;
+    case GSL_WAVE_LOOP_NONE:
+      wchunk->loop_type = loop_type;
+      wchunk->loop_first = wchunk->length + 1;
+      wchunk->loop_last = -1;
+      wchunk->loop_count = 0;
+      wchunk->wave_length = wchunk->length;
+      break;
+    }
+  wchunk->pploop_ends_backwards = wchunk->loop_type == GSL_WAVE_LOOP_PINGPONG && (wchunk->loop_count & 1);
+  wchunk->mini_loop = wchunk->loop_type && wchunk->loop_last - wchunk->loop_first < 2 * big_pad + padding;
+}
+
+GslWaveChunk*
+gsl_wave_chunk_new (GslDataCache   *dcache,
+		    gfloat          osc_freq,
+		    gfloat          mix_freq,
+		    GslWaveLoopType loop_type,
+		    GslLong         loop_first,
+		    GslLong         loop_last,
+		    guint           loop_count)
+{
+  GslWaveChunk *wchunk;
+
+  g_return_val_if_fail (dcache != NULL, NULL);
+  g_return_val_if_fail (osc_freq < mix_freq / 2, NULL);
+  g_return_val_if_fail (loop_type >= GSL_WAVE_LOOP_NONE && loop_type <= GSL_WAVE_LOOP_PINGPONG, NULL);
+
+  wchunk = gsl_new_struct0 (GslWaveChunk, 1);
+  wchunk->dcache = gsl_data_cache_ref (dcache);
+  wchunk->length = 0;
+  wchunk->n_channels = 0;
+  wchunk->n_pad_values = 0;
+  wchunk->wave_length = 0;
+  wchunk->loop_type = GSL_WAVE_LOOP_NONE;
+  wchunk->leave_end_norm = 0;
+  wchunk->tail_start_norm = 0;
+  wchunk->ref_count = 1;
+  wchunk->open_count = 0;
+  wchunk->mix_freq = mix_freq;
+  wchunk->osc_freq = osc_freq;
+  wchunk->requested_loop_type = loop_type;
+  wchunk->requested_loop_first = loop_first;
+  wchunk->requested_loop_last = loop_last;
+  wchunk->requested_loop_count = loop_count;
+
+  return wchunk;
+}
+
+GslWaveChunk*
+gsl_wave_chunk_ref (GslWaveChunk *wchunk)
+{
+  g_return_val_if_fail (wchunk != NULL, NULL);
+  g_return_val_if_fail (wchunk->ref_count > 0, NULL);
+
+  wchunk->ref_count++;
+  return wchunk;
+}
+
+void
+gsl_wave_chunk_unref (GslWaveChunk *wchunk)
+{
+  g_return_if_fail (wchunk != NULL);
+  g_return_if_fail (wchunk->ref_count > 0);
+
+  wchunk->ref_count--;
+  if (wchunk->ref_count == 0)
+    {
+      g_return_if_fail (wchunk->open_count == 0);
+      gsl_data_cache_unref (wchunk->dcache);
+      gsl_delete_struct (GslWaveChunk, wchunk);
+    }
+}
+
+GslErrorType
+gsl_wave_chunk_open (GslWaveChunk *wchunk)
+{
+  g_return_val_if_fail (wchunk != NULL, GSL_ERROR_INTERNAL);
+  g_return_val_if_fail (wchunk->ref_count > 0, GSL_ERROR_INTERNAL);
+
+  if (wchunk->open_count == 0)
+    {
+      GslErrorType error;
+
+      error = gsl_data_handle_open (wchunk->dcache->dhandle);
+      if (error != GSL_ERROR_NONE)
+	return error;
+      if (gsl_data_handle_n_values (wchunk->dcache->dhandle) < gsl_data_handle_n_channels (wchunk->dcache->dhandle))
+	{
+	  gsl_data_handle_close (wchunk->dcache->dhandle);
+	  return GSL_ERROR_FILE_EMPTY;
+	}
+      wchunk->n_channels = gsl_data_handle_n_channels (wchunk->dcache->dhandle);
+      wchunk->length = gsl_data_handle_n_values (wchunk->dcache->dhandle) / wchunk->n_channels;
+      wchunk->length *= wchunk->n_channels;
+      wchunk->n_pad_values = gsl_get_config ()->wave_chunk_padding * wchunk->n_channels;
+      gsl_data_cache_open (wchunk->dcache);
+      gsl_data_handle_close (wchunk->dcache->dhandle);
+      g_return_val_if_fail (wchunk->dcache->padding >= wchunk->n_pad_values, GSL_ERROR_INTERNAL);
+      wchunk->open_count++;
+      wchunk->ref_count++;
+      wave_chunk_setup_loop (wchunk);
+      setup_pblocks (wchunk);
+    }
+  else
+    wchunk->open_count++;
+  return GSL_ERROR_NONE;
+}
+
+void
+gsl_wave_chunk_close (GslWaveChunk *wchunk)
+{
+  GslLong padding;
+
+  g_return_if_fail (wchunk != NULL);
+  g_return_if_fail (wchunk->open_count > 0);
+  g_return_if_fail (wchunk->ref_count > 0);
+
+  wchunk->open_count--;
+  if (wchunk->open_count)
+    return;
+
+  padding = wchunk->n_pad_values;
+  gsl_data_cache_close (wchunk->dcache);
+  if (wchunk->head.mem)
+    gsl_delete_structs (gfloat, wchunk->head.length + 2 * padding, wchunk->head.mem - padding);
+  memset (&wchunk->head, 0, sizeof (GslWaveChunkMem));
+  if (wchunk->enter.mem)
+    gsl_delete_structs (gfloat, wchunk->enter.length + 2 * padding, wchunk->enter.mem - padding);
+  memset (&wchunk->enter, 0, sizeof (GslWaveChunkMem));
+  if (wchunk->wrap.mem)
+    gsl_delete_structs (gfloat, wchunk->wrap.length + 2 * padding, wchunk->wrap.mem - padding);
+  memset (&wchunk->wrap, 0, sizeof (GslWaveChunkMem));
+  if (wchunk->ppwrap.mem)
+    gsl_delete_structs (gfloat, wchunk->ppwrap.length + 2 * padding, wchunk->ppwrap.mem - padding);
+  memset (&wchunk->ppwrap, 0, sizeof (GslWaveChunkMem));
+  if (wchunk->leave.mem)
+    gsl_delete_structs (gfloat, wchunk->leave.length + 2 * padding, wchunk->leave.mem - padding);
+  memset (&wchunk->leave, 0, sizeof (GslWaveChunkMem));
+  if (wchunk->tail.mem)
+    gsl_delete_structs (gfloat, wchunk->tail.length + 2 * padding, wchunk->tail.mem - padding);
+  memset (&wchunk->tail, 0, sizeof (GslWaveChunkMem));
+  wchunk->length = 0;
+  wchunk->n_channels = 0;
+  wchunk->n_pad_values = 0;
+  wchunk->wave_length = 0;
+  wchunk->loop_type = GSL_WAVE_LOOP_NONE;
+  wchunk->leave_end_norm = 0;
+  wchunk->tail_start_norm = 0;
+  gsl_wave_chunk_unref (wchunk);
+}
+
+void
+gsl_wave_chunk_debug_block (GslWaveChunk *wchunk,
+			    GslLong       offset,
+			    GslLong       length,
+			    gfloat	 *block)
+{
+  g_return_if_fail (wchunk != NULL);
+
+  fill_block (wchunk, block, offset, length, FALSE, wchunk->loop_count);
+}
+
+GslWaveChunk*
+_gsl_wave_chunk_copy (GslWaveChunk *wchunk)
+{
+  g_return_val_if_fail (wchunk != NULL, NULL);
+  g_return_val_if_fail (wchunk->ref_count > 0, NULL);
+
+  return gsl_wave_chunk_new (wchunk->dcache,
+			     wchunk->osc_freq,
+			     wchunk->mix_freq,
+			     wchunk->loop_type,
+			     wchunk->loop_first,
+			     wchunk->loop_last,
+			     wchunk->loop_count);
+}
+
+const gchar*
+gsl_wave_loop_type_to_string (GslWaveLoopType wave_loop)
+{
+  g_return_val_if_fail (wave_loop >= GSL_WAVE_LOOP_NONE && wave_loop <= GSL_WAVE_LOOP_PINGPONG, NULL);
+
+  switch (wave_loop)
+    {
+    case GSL_WAVE_LOOP_NONE:		return "none";
+    case GSL_WAVE_LOOP_JUMP:		return "jump";
+    case GSL_WAVE_LOOP_PINGPONG:	return "pingpong";
+    default:				return NULL;
+    }
+}
+
+GslWaveLoopType
+gsl_wave_loop_type_from_string (const gchar *string)
+{
+  g_return_val_if_fail (string != NULL, 0);
+
+  while (*string == ' ')
+    string++;
+  if (strncasecmp (string, "jump", 4) == 0)
+    return GSL_WAVE_LOOP_JUMP;
+  if (strncasecmp (string, "pingpong", 8) == 0)
+    return GSL_WAVE_LOOP_PINGPONG;
+  return GSL_WAVE_LOOP_NONE;
+}
diff --git a/flow/gsl/gslwavechunk.h b/flow/gsl/gslwavechunk.h
new file mode 100644
index 0000000..c4deaf5
--- /dev/null
+++ b/flow/gsl/gslwavechunk.h
@@ -0,0 +1,129 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_WAVE_CHUNK_H__
+#define __GSL_WAVE_CHUNK_H__
+
+#include <gsl/gsldefs.h>
+#include <gsl/gsldatacache.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/* --- typedefs & structures --- */
+typedef enum /*< skip >*/
+{
+  GSL_WAVE_LOOP_NONE,
+  GSL_WAVE_LOOP_JUMP,
+  GSL_WAVE_LOOP_PINGPONG
+} GslWaveLoopType;
+typedef struct
+{
+  GslLong start, end, length;
+  gfloat *mem;
+} GslWaveChunkMem;
+struct _GslWaveChunk
+{
+  /* wave chunk data residency */
+  GslDataCache   *dcache;
+  GslLong	  length;	/* number of per-channel-values * n-channels */
+
+  /* chunk specific parameters */
+  gint		  n_channels;
+  GslLong	  n_pad_values;	/* guaranteed pad values around blocks */
+  GslLong	  wave_length;	/* start + loop duration + end (single channel) */
+
+  /* flags */
+  guint		  pploop_ends_backwards : 1;
+  guint		  mini_loop : 1;
+
+  /* loop spec */
+  GslWaveLoopType loop_type;
+  GslLong	  loop_first;
+  GslLong	  loop_last;
+  guint		  loop_count;
+
+  /* preformatted blocks */
+  GslWaveChunkMem head;
+  GslWaveChunkMem enter;
+  GslWaveChunkMem wrap;
+  GslWaveChunkMem ppwrap;
+  GslWaveChunkMem leave;
+  GslWaveChunkMem tail;
+  GslLong	  leave_end_norm;
+  GslLong	  tail_start_norm;
+
+  GslWaveLoopType requested_loop_type;
+  GslLong         requested_loop_first;
+  GslLong         requested_loop_last;
+  guint           requested_loop_count;
+  guint           ref_count;
+  guint           open_count;
+  /* legacy */
+  gfloat	  mix_freq;	/* recorded with mix_freq */
+  gfloat	  osc_freq;	/* while oscillating at osc_freq */
+};
+struct _GslWaveChunkBlock
+{
+  /* requisition (in) */
+  gint		play_dir;	/* usually +1 */
+  GslLong	offset;		/* requested offset into wave */
+  /* result (out) */
+  GslLong	length;		/* resulting signed? length of block in # values */
+  gboolean	is_silent;	/* sample end reached, values are 0 */
+  gint		dirstride;	/* >0 => increment, <0 => decrement */
+  gfloat       *start;		/* first data value location */
+  gfloat       *end;		/* last data value location +1 */
+  GslLong	next_offset;	/* offset of next adjunct block */
+  /*< private >*/
+  gpointer	node;
+};
+
+
+/* --- prototypes --- */
+void		gsl_wave_chunk_use_block	(GslWaveChunk		*wave_chunk,
+						 GslWaveChunkBlock	*block);
+void		gsl_wave_chunk_unuse_block	(GslWaveChunk		*wave_chunk,
+						 GslWaveChunkBlock	*block);
+GslWaveChunk*	gsl_wave_chunk_new		(GslDataCache		*dcache,
+						 gfloat			 osc_freq,
+						 gfloat			 mix_freq,
+						 GslWaveLoopType	 loop_type,
+						 GslLong		 loop_first,
+						 GslLong		 loop_end,
+						 guint			 loop_count);
+GslWaveChunk*	gsl_wave_chunk_ref		(GslWaveChunk		*wchunk);
+void		gsl_wave_chunk_unref		(GslWaveChunk		*wchunk);
+GslErrorType	gsl_wave_chunk_open		(GslWaveChunk		*wchunk);
+void		gsl_wave_chunk_close		(GslWaveChunk		*wchunk);
+void		gsl_wave_chunk_debug_block	(GslWaveChunk		*wchunk,
+						 GslLong		 offset,
+						 GslLong		 length,
+						 gfloat			*block);
+GslWaveChunk*	_gsl_wave_chunk_copy		(GslWaveChunk		*wchunk);
+const gchar*	gsl_wave_loop_type_to_string	(GslWaveLoopType	 wave_loop);
+GslWaveLoopType	gsl_wave_loop_type_from_string	(const gchar		*string);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_WAVE_CHUNK_H__ */
diff --git a/flow/gsl/gslwaveloader.c b/flow/gsl/gslwaveloader.c
new file mode 100644
index 0000000..cd097d9
--- /dev/null
+++ b/flow/gsl/gslwaveloader.c
@@ -0,0 +1,2 @@
+#include <gsl/gslwaveloader.h>
+
diff --git a/flow/gsl/gslwaveloader.h b/flow/gsl/gslwaveloader.h
new file mode 100644
index 0000000..7453359
--- /dev/null
+++ b/flow/gsl/gslwaveloader.h
@@ -0,0 +1,6 @@
+
+#ifndef GSLWAVELOADER_H
+#define GSLWAVELOADER_H
+
+#endif // GSLWAVELOADER_H
+
diff --git a/flow/gsl/gslwaveosc-aux.c b/flow/gsl/gslwaveosc-aux.c
new file mode 100644
index 0000000..4485242
--- /dev/null
+++ b/flow/gsl/gslwaveosc-aux.c
@@ -0,0 +1,249 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+
+#define CHECK_SYNC		(WOSC_MIX_VARIANT & WOSC_MIX_WITH_SYNC)
+#define CHECK_FREQ		(WOSC_MIX_VARIANT & WOSC_MIX_WITH_FREQ)
+#define CHECK_MOD		(WOSC_MIX_VARIANT & WOSC_MIX_WITH_MOD)
+#define EXPONENTIAL_FM		(WOSC_MIX_VARIANT & WOSC_MIX_WITH_EXP_FM)
+#define DIRSTRIDE(b)		(b->dirstride)	 /* (1) change for n_channel stepping */
+
+
+static void
+WOSC_MIX_VARIANT_NAME (GslWaveOscData *wosc,
+		       guint           n_values,
+		       const gfloat   *freq_in,
+		       const gfloat   *mod_in,
+		       const gfloat   *sync_in,
+		       gfloat         *wave_out)
+{
+  gfloat *wave_boundary;
+  gfloat last_sync_level = wosc->last_sync_level;
+  gfloat last_freq_level = wosc->last_freq_level;
+  gfloat last_mod_level = wosc->last_mod_level;
+  GslWaveChunkBlock *block = &wosc->block;
+  gdouble *a = wosc->a, *b = wosc->b, *y = wosc->y;
+  gfloat *boundary = block->end;
+  guint wosc_j = wosc->j;
+
+  /* do the mixing */
+  wave_boundary = wave_out + n_values;
+  do
+    {
+      gfloat ffrac;
+
+      if (CHECK_SYNC)
+	{
+	  gfloat sync_level = *sync_in++;
+	  if_reject (GSL_SIGNAL_RAISING_EDGE (last_sync_level, sync_level))
+	    {
+	      wosc->j = wosc_j;
+	      gsl_wave_osc_retrigger (wosc, CHECK_FREQ ? GSL_SIGNAL_TO_FREQ (*freq_in) : wosc->config.cfreq);
+	      /* retrigger alters last_freq and last_mod */
+	      last_freq_level = wosc->last_freq_level;
+	      last_mod_level = wosc->last_mod_level;
+	      wosc_j = wosc->j;
+	      boundary = block->end;
+	      /* FIXME: g_assert (ABS (block->dirstride) == 1); */
+	      last_sync_level = sync_level;
+	    }
+	}
+      if (CHECK_MOD && CHECK_FREQ)
+	{
+	  gfloat mod_level = *mod_in++, freq_level = *freq_in++;
+	  if_reject (GSL_SIGNAL_FREQ_CHANGED (last_freq_level, freq_level))
+	    {
+	      last_freq_level = freq_level;
+	      if (GSL_SIGNAL_MOD_CHANGED (last_mod_level, mod_level))
+		last_mod_level = mod_level;
+	      goto UPDATE_FREQ;
+	    }
+          else if_reject (GSL_SIGNAL_MOD_CHANGED (last_mod_level, mod_level))
+	    {
+	      gfloat new_freq;
+	      last_mod_level = mod_level;
+	    UPDATE_FREQ:
+	      new_freq = GSL_SIGNAL_TO_FREQ (freq_level);
+	      if (EXPONENTIAL_FM)
+		new_freq *= gsl_signal_exp2 (wosc->config.fm_strength * mod_level);
+	      else /* LINEAR_FM */
+		new_freq *= 1.0 + wosc->config.fm_strength * mod_level;
+	      wave_osc_transform_filter (wosc, new_freq);
+	    }
+	}
+      else if (CHECK_MOD)
+	{
+	  gfloat mod_level = *mod_in++;
+	  if (GSL_SIGNAL_MOD_CHANGED (last_mod_level, mod_level))
+	    {
+	      gfloat new_freq = wosc->config.cfreq;
+	      if (EXPONENTIAL_FM)
+		new_freq *= gsl_signal_exp2 (wosc->config.fm_strength * mod_level);
+	      else /* LINEAR_FM */
+		new_freq *= 1.0 + wosc->config.fm_strength * mod_level;
+	      last_mod_level = mod_level;
+	      wave_osc_transform_filter (wosc, new_freq);
+	    }
+	}
+      else if (CHECK_FREQ)
+	{
+	  gfloat freq_level = *freq_in++;
+	  if (GSL_SIGNAL_FREQ_CHANGED (last_freq_level, freq_level))
+	    {
+	      last_freq_level = freq_level;
+	      wave_osc_transform_filter (wosc, GSL_SIGNAL_TO_FREQ (freq_level));
+	    }
+	}
+
+      /* process filter while necesary */
+      while (wosc->cur_pos >= (FRAC_MASK + 1) << 1)
+	{
+	  gfloat c, c0, c1, c2, c3, c4, c5, c6, c7, c8;
+	  gfloat d, d0, d1, d2, d3, d4, d5, d6, d7;
+	  gfloat *x;
+
+	  if_reject (wosc->x >= boundary)       /* wchunk block boundary */
+	    {
+	      GslLong next_offset = block->next_offset;
+
+	      gsl_wave_chunk_unuse_block (wosc->wchunk, block);
+	      block->play_dir = wosc->config.play_dir;
+	      block->offset = next_offset;
+	      gsl_wave_chunk_use_block (wosc->wchunk, block);
+	      wosc->x = block->start + wosc->config.channel;
+	      boundary = block->end;
+	      /* FIXME: g_assert (ABS (block->dirstride) == 1); */
+	    }
+
+	  if_expect (block->dirstride > 0)
+	    {
+	      x = wosc->x;
+	      d0 = b[0] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d1 = b[1] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d2 = b[2] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d3 = b[3] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d4 = b[4] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d5 = b[5] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d6 = b[6] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d7 = b[7] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      c8 = a[8] * x[-4 * DIRSTRIDE (block)];
+	      c6 = a[6] * x[-3 * DIRSTRIDE (block)];
+	      c4 = a[4] * x[-2 * DIRSTRIDE (block)];
+	      c2 = a[2] * x[-1 * DIRSTRIDE (block)];
+	      c0 = a[0] * x[0 * DIRSTRIDE (block)];
+	      d = d0 + d1 + d2 + d3 + d4 + d5 + d6 + d7;
+	      c = c0 + c2 + c4 + c6 + c8;
+	      y[wosc_j] = c - d; wosc_j++; wosc_j &= 0x7;
+	      d0 = b[0] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d1 = b[1] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d2 = b[2] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d3 = b[3] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d4 = b[4] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d5 = b[5] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d6 = b[6] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d7 = b[7] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      c7 = a[7] * x[-3 * DIRSTRIDE (block)];
+	      c5 = a[5] * x[-2 * DIRSTRIDE (block)];
+	      c3 = a[3] * x[-1 * DIRSTRIDE (block)];
+	      c1 = a[1] * x[0 * DIRSTRIDE (block)];
+	      d = d0 + d1 + d2 + d3 + d4 + d5 + d6 + d7;
+	      c = c1 + c3 + c5 + c7;
+	      y[wosc_j] = c - d; wosc_j++; wosc_j &= 0x7;
+	      wosc->x += DIRSTRIDE (block);
+	    }
+          else /* dirstride < 0 */
+	    {
+	      x = wosc->x;
+	      d0 = b[0] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d1 = b[1] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d2 = b[2] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d3 = b[3] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d4 = b[4] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d5 = b[5] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d6 = b[6] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d7 = b[7] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      c8 = a[8] * x[-4 * -DIRSTRIDE (block)];
+	      c6 = a[6] * x[-3 * -DIRSTRIDE (block)];
+	      c4 = a[4] * x[-2 * -DIRSTRIDE (block)];
+	      c2 = a[2] * x[-1 * -DIRSTRIDE (block)];
+	      c0 = a[0] * x[0 * -DIRSTRIDE (block)];
+	      d = d0 + d1 + d2 + d3 + d4 + d5 + d6 + d7;
+	      c = c0 + c2 + c4 + c6 + c8;
+	      y[wosc_j] = c - d; wosc_j++; wosc_j &= 0x7;
+	      d0 = b[0] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d1 = b[1] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d2 = b[2] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d3 = b[3] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d4 = b[4] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d5 = b[5] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d6 = b[6] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      d7 = b[7] * y[wosc_j]; wosc_j++; wosc_j &= 0x7;
+	      c7 = a[7] * x[-3 * -DIRSTRIDE (block)];
+	      c5 = a[5] * x[-2 * -DIRSTRIDE (block)];
+	      c3 = a[3] * x[-1 * -DIRSTRIDE (block)];
+	      c1 = a[1] * x[0 * -DIRSTRIDE (block)];
+	      d = d0 + d1 + d2 + d3 + d4 + d5 + d6 + d7;
+	      c = c1 + c3 + c5 + c7;
+	      y[wosc_j] = c - d; wosc_j++; wosc_j &= 0x7;
+	      wosc->x += -DIRSTRIDE (block);
+	    }
+
+	  wosc->cur_pos -= (FRAC_MASK + 1) << 1;
+	}
+
+      /* interpolate filter output from current pos
+       * wosc->cur_pos >> FRAC_SHIFT is 1 or 0;
+       */
+      if (wosc->cur_pos >> FRAC_SHIFT)
+	{
+	  guint k = wosc_j - 2;
+
+	  ffrac = wosc->cur_pos & FRAC_MASK;    /* int -> float */
+	  ffrac *= 1. / (FRAC_MASK + 1.);
+	  *wave_out++ = y[k & 0x7] * (1.0 - ffrac) + y[(k + 1) & 0x7] * ffrac;
+	}
+      else
+	{
+	  guint k = wosc_j - 3;
+
+	  ffrac = wosc->cur_pos;                /* int -> float */
+	  ffrac *= 1. / (FRAC_MASK + 1.);
+	  *wave_out++ = y[k & 0x7] * (1.0 - ffrac) + y[(k + 1) & 0x7] * ffrac;
+	}
+
+      /* increment */
+      wosc->cur_pos += wosc->istep;
+    }
+  while (wave_out < wave_boundary);
+  wosc->j = wosc_j;
+  wosc->last_sync_level = last_sync_level;
+  wosc->last_freq_level = last_freq_level;
+  wosc->last_mod_level = last_mod_level;
+}
+
+#undef CHECK_SYNC
+#undef CHECK_FREQ
+#undef CHECK_MOD
+#undef EXPONENTIAL_FM
+#undef DIRSTRIDE
+
+#undef WOSC_MIX_VARIANT
+#undef WOSC_MIX_VARIANT_NAME
+
+/* vim:set ts=8 sw=2 sts=2: */
diff --git a/flow/gsl/gslwaveosc.c b/flow/gsl/gslwaveosc.c
new file mode 100644
index 0000000..a17c836
--- /dev/null
+++ b/flow/gsl/gslwaveosc.c
@@ -0,0 +1,376 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#include "gslwaveosc.h"
+
+#include "gslfilter.h"
+#include "gslsignal.h"
+#include "gslengine.h"	/* for gsl_engine_sample_freq() */
+#include <string.h>
+
+
+#define FRAC_SHIFT		(16)
+#define FRAC_MASK		((1 << FRAC_SHIFT) - 1)
+#define	SIGNAL_LEVEL_INVAL	(-2.0)	/* trigger level-changed checks */
+
+
+/* --- prototype --- */
+static void	wave_osc_transform_filter	(GslWaveOscData *wosc,
+						 gfloat          play_freq);
+
+
+/* --- generated function variants --- */
+#define WOSC_MIX_VARIANT_INVAL  (0xffffffff)
+#define WOSC_MIX_WITH_SYNC      (1)
+#define WOSC_MIX_WITH_FREQ      (2)
+#define WOSC_MIX_WITH_MOD       (4)
+#define WOSC_MIX_WITH_EXP_FM    (8)
+#define WOSC_MIX_VARIANT_NAME	wosc_process_sfme
+#define WOSC_MIX_VARIANT	(WOSC_MIX_WITH_SYNC | WOSC_MIX_WITH_FREQ | WOSC_MIX_WITH_MOD | WOSC_MIX_WITH_EXP_FM)
+#include "gslwaveosc-aux.c"
+#define WOSC_MIX_VARIANT_NAME	wosc_process_sfm_
+#define WOSC_MIX_VARIANT	(WOSC_MIX_WITH_SYNC | WOSC_MIX_WITH_FREQ | WOSC_MIX_WITH_MOD | 0                   )
+#include "gslwaveosc-aux.c"
+#if 0
+#define WOSC_MIX_VARIANT_NAME	wosc_process_sf_e
+#define WOSC_MIX_VARIANT	(WOSC_MIX_WITH_SYNC | WOSC_MIX_WITH_FREQ | 0                 | WOSC_MIX_WITH_EXP_FM)
+#include "gslwaveosc-aux.c"
+#endif
+#define WOSC_MIX_VARIANT_NAME	wosc_process_sf__
+#define WOSC_MIX_VARIANT	(WOSC_MIX_WITH_SYNC | WOSC_MIX_WITH_FREQ | 0                 | 0                   )
+#include "gslwaveosc-aux.c"
+#define WOSC_MIX_VARIANT_NAME	wosc_process_s_me
+#define WOSC_MIX_VARIANT	(WOSC_MIX_WITH_SYNC | 0                  | WOSC_MIX_WITH_MOD | WOSC_MIX_WITH_EXP_FM)
+#include "gslwaveosc-aux.c"
+#define WOSC_MIX_VARIANT_NAME	wosc_process_s_m_
+#define WOSC_MIX_VARIANT	(WOSC_MIX_WITH_SYNC | 0                  | WOSC_MIX_WITH_MOD | 0                   )
+#include "gslwaveosc-aux.c"
+#if 0
+#define WOSC_MIX_VARIANT_NAME	wosc_process_s__e
+#define WOSC_MIX_VARIANT	(WOSC_MIX_WITH_SYNC | 0                  | 0                 | WOSC_MIX_WITH_EXP_FM)
+#include "gslwaveosc-aux.c"
+#endif
+#define WOSC_MIX_VARIANT_NAME	wosc_process_s___
+#define WOSC_MIX_VARIANT	(WOSC_MIX_WITH_SYNC | 0                  | 0                 | 0                   )
+#include "gslwaveosc-aux.c"
+#define WOSC_MIX_VARIANT_NAME	wosc_process__fme
+#define WOSC_MIX_VARIANT	(0                  | WOSC_MIX_WITH_FREQ | WOSC_MIX_WITH_MOD | WOSC_MIX_WITH_EXP_FM)
+#include "gslwaveosc-aux.c"
+#define WOSC_MIX_VARIANT_NAME	wosc_process__fm_
+#define WOSC_MIX_VARIANT	(0                  | WOSC_MIX_WITH_FREQ | WOSC_MIX_WITH_MOD | 0                   )
+#include "gslwaveosc-aux.c"
+#if 0
+#define WOSC_MIX_VARIANT_NAME	wosc_process__f_e
+#define WOSC_MIX_VARIANT	(0                  | WOSC_MIX_WITH_FREQ | 0                 | WOSC_MIX_WITH_EXP_FM)
+#include "gslwaveosc-aux.c"
+#endif
+#define WOSC_MIX_VARIANT_NAME	wosc_process__f__
+#define WOSC_MIX_VARIANT	(0                  | WOSC_MIX_WITH_FREQ | 0                 | 0                   )
+#include "gslwaveosc-aux.c"
+#define WOSC_MIX_VARIANT_NAME	wosc_process___me
+#define WOSC_MIX_VARIANT	(0                  | 0                  | WOSC_MIX_WITH_MOD | WOSC_MIX_WITH_EXP_FM)
+#include "gslwaveosc-aux.c"
+#define WOSC_MIX_VARIANT_NAME	wosc_process___m_
+#define WOSC_MIX_VARIANT	(0                  | 0                  | WOSC_MIX_WITH_MOD | 0                   )
+#include "gslwaveosc-aux.c"
+#if 0
+#define WOSC_MIX_VARIANT_NAME	wosc_process____e
+#define WOSC_MIX_VARIANT	(0                  | 0                  | 0                 | WOSC_MIX_WITH_EXP_FM)
+#include "gslwaveosc-aux.c"
+#endif
+#define WOSC_MIX_VARIANT_NAME	wosc_process_____
+#define WOSC_MIX_VARIANT	(0                  | 0                  | 0                 | 0                   )
+#include "gslwaveosc-aux.c"
+
+
+/* --- functions --- */
+gboolean
+gsl_wave_osc_process (GslWaveOscData *wosc,
+		      guint           n_values,
+		      const gfloat   *freq_in,
+		      const gfloat   *mod_in,
+		      const gfloat   *sync_in,
+		      gfloat         *mono_out)
+{
+  guint mode = 0;
+
+  g_return_val_if_fail (wosc != NULL, FALSE);
+  g_return_val_if_fail (n_values > 0, FALSE);
+  g_return_val_if_fail (mono_out != NULL, FALSE);
+
+  if_reject (!wosc->config.wchunk_from_freq)
+    return FALSE;
+
+  /* mode changes:
+   * freq_in:	if (freq_in) last_freq=inval else set_filter()
+   * sync_in:	last_sync=0
+   * mod_in:	if (mod_in) last_mod=0 else if (freq_in) last_freq=inval else transform_filter()
+   * exp_mod:	n/a
+   */
+
+  if (sync_in)
+    mode |= WOSC_MIX_WITH_SYNC;
+  if (freq_in)
+    mode |= WOSC_MIX_WITH_FREQ;
+  if (mod_in)
+    mode |= WOSC_MIX_WITH_MOD;
+  if (wosc->config.exponential_fm)
+    mode |= WOSC_MIX_WITH_EXP_FM;
+
+  if_reject (mode != wosc->last_mode)
+    {
+      guint mask = wosc->last_mode ^ mode;
+
+      if (mask & WOSC_MIX_WITH_SYNC)
+	wosc->last_sync_level = 0;
+      if (mask & WOSC_MIX_WITH_FREQ)
+	{
+	  if (freq_in)
+	    wosc->last_freq_level = SIGNAL_LEVEL_INVAL;
+	  else
+	    gsl_wave_osc_set_filter (wosc, wosc->config.cfreq, FALSE);
+	}
+      if (mask & WOSC_MIX_WITH_MOD)
+	{
+	  if (mod_in)
+	    wosc->last_mod_level = 0;
+	  else if (freq_in)
+	    wosc->last_freq_level = SIGNAL_LEVEL_INVAL;
+	  else /* !mod_in && !freq_in */
+	    wave_osc_transform_filter (wosc, wosc->config.cfreq);
+	}
+      wosc->last_mode = mode;
+    }
+
+  switch (mode)
+    {
+    case 0                  | 0                  | 0                 | 0:
+    case 0                  | 0                  | 0                 | WOSC_MIX_WITH_EXP_FM:
+      wosc_process_____ (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case 0                  | 0                  | WOSC_MIX_WITH_MOD | 0:
+      wosc_process___m_ (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case 0                  | 0                  | WOSC_MIX_WITH_MOD | WOSC_MIX_WITH_EXP_FM:
+      wosc_process___me (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case 0                  | WOSC_MIX_WITH_FREQ | 0                 | 0:
+    case 0                  | WOSC_MIX_WITH_FREQ | 0                 | WOSC_MIX_WITH_EXP_FM:
+      wosc_process__f__ (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case 0                  | WOSC_MIX_WITH_FREQ | WOSC_MIX_WITH_MOD | 0:
+      wosc_process__fm_ (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case 0                  | WOSC_MIX_WITH_FREQ | WOSC_MIX_WITH_MOD | WOSC_MIX_WITH_EXP_FM:
+      wosc_process__fme (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case WOSC_MIX_WITH_SYNC | 0                  | 0                 | 0:
+    case WOSC_MIX_WITH_SYNC | 0                  | 0                 | WOSC_MIX_WITH_EXP_FM:
+      wosc_process_s___ (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case WOSC_MIX_WITH_SYNC | 0                  | WOSC_MIX_WITH_MOD | 0:
+      wosc_process_s_m_ (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case WOSC_MIX_WITH_SYNC | 0                  | WOSC_MIX_WITH_MOD | WOSC_MIX_WITH_EXP_FM:
+      wosc_process_s_me (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case WOSC_MIX_WITH_SYNC | WOSC_MIX_WITH_FREQ | 0                 | 0:
+    case WOSC_MIX_WITH_SYNC | WOSC_MIX_WITH_FREQ | 0                 | WOSC_MIX_WITH_EXP_FM:
+      wosc_process_sf__ (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case WOSC_MIX_WITH_SYNC | WOSC_MIX_WITH_FREQ | WOSC_MIX_WITH_MOD | 0:
+      wosc_process_sfm_ (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    case WOSC_MIX_WITH_SYNC | WOSC_MIX_WITH_FREQ | WOSC_MIX_WITH_MOD | WOSC_MIX_WITH_EXP_FM:
+      wosc_process_sfme (wosc, n_values, freq_in, mod_in, sync_in, mono_out);
+      break;
+    default:
+      g_assert_not_reached ();
+    }
+
+  if (wosc->y[0] != 0.0 &&
+      !(fabs (wosc->y[0]) > GSL_SIGNAL_EPSILON && fabs (wosc->y[0]) < GSL_SIGNAL_KAPPA))
+    {
+      guint i;
+
+      /*g_printerr ("clearing filter state at:\n");*/
+      for (i = 0; i < GSL_WAVE_OSC_FILTER_ORDER; i++)
+	{
+	  /*g_printerr ("%u) %+.38f\n", i, wosc->y[i]);*/
+	  if (GSL_DOUBLE_IS_INF (wosc->y[0]) || fabs (wosc->y[0]) > GSL_SIGNAL_KAPPA)
+	    wosc->y[i] = GSL_DOUBLE_SIGN (wosc->y[0]) ? -1.0 : 1.0;
+	  else
+	    wosc->y[i] = 0.0;
+	}
+    }
+  g_assert (!GSL_DOUBLE_IS_NANINF (wosc->y[0]));
+  g_assert (!GSL_DOUBLE_IS_SUBNORMAL (wosc->y[0]));
+
+  wosc->done = (wosc->block.is_silent &&   /* FIXME, let filter state run out? */
+		((wosc->block.play_dir < 0 && wosc->block.offset < 0) ||
+		 (wosc->block.play_dir > 0 && wosc->block.offset > wosc->wchunk->wave_length)));
+
+  return TRUE;
+}
+
+void
+gsl_wave_osc_set_filter (GslWaveOscData *wosc,
+			 gfloat          play_freq,
+			 gboolean	 clear_state)
+{
+  gfloat zero_padding = 2;
+  gfloat step;
+  guint i, istep;
+
+  g_return_if_fail (play_freq > 0);
+
+  if_reject (!wosc->config.wchunk_from_freq)
+    return;
+
+  wosc->step_factor = zero_padding * wosc->wchunk->mix_freq;
+  wosc->step_factor /= wosc->wchunk->osc_freq * wosc->mix_freq;
+  step = wosc->step_factor * play_freq;
+  istep = step * (FRAC_MASK + 1.) + 0.5;
+
+  if (istep != wosc->istep)
+    {
+      gfloat nyquist_fact = GSL_PI * 2.0 / wosc->mix_freq, cutoff_freq = 18000, stop_freq = 24000;
+      gfloat empiric_filter_stability_limit = 6.;
+      gfloat filt_fact = CLAMP (1. / step,
+				1. / (empiric_filter_stability_limit * zero_padding),
+				1. / zero_padding /* spectrum half */);
+      gfloat freq_c = cutoff_freq * nyquist_fact * filt_fact;
+      gfloat freq_r = stop_freq * nyquist_fact * filt_fact;
+
+      /* FIXME: this should store filter roots and poles, so modulation does lp->lp transform */
+
+      wosc->istep = istep;
+      gsl_filter_tscheb2_lp (GSL_WAVE_OSC_FILTER_ORDER, freq_c, freq_r / freq_c, 0.18, wosc->a, wosc->b);
+      for (i = 0; i < GSL_WAVE_OSC_FILTER_ORDER + 1; i++)
+	wosc->a[i] *= zero_padding;	/* scale to compensate for zero-padding */
+      for (i = 0; i < (GSL_WAVE_OSC_FILTER_ORDER + 1) / 2; i++)     /* reverse bs */
+	{
+	  gfloat t = wosc->b[GSL_WAVE_OSC_FILTER_ORDER - i];
+
+	  wosc->b[GSL_WAVE_OSC_FILTER_ORDER - i] = wosc->b[i];
+	  wosc->b[i] = t;
+	}
+      /*g_printerr ("filter: fc=%f fr=%f st=%f is=%u\n", freq_c/GSL_PI*2, freq_r/GSL_PI*2, step, wosc->istep);*/
+    }
+
+  if (clear_state)
+    {
+      /* clear filter state */
+      memset (wosc->y, 0, sizeof (wosc->y));
+      wosc->j = 0;
+      wosc->cur_pos = 0;    /* might want to initialize with istep? */
+    }
+}
+
+static void
+wave_osc_transform_filter (GslWaveOscData *wosc,
+			   gfloat          play_freq)
+{
+  gfloat step;
+  guint istep;
+
+  step = wosc->step_factor * play_freq;
+  istep = step * (FRAC_MASK + 1.) + 0.5;
+  if (istep != wosc->istep)
+    {
+      wosc->istep = istep;
+      /* transform filter poles and roots, normalize filter, update a[] and b[] */
+    }
+}
+
+void
+gsl_wave_osc_retrigger (GslWaveOscData *wosc,
+			gfloat          base_freq)
+{
+  g_return_if_fail (wosc != NULL);
+
+  if_reject (!wosc->config.wchunk_from_freq)
+    return;
+
+  if (wosc->wchunk)
+    gsl_wave_chunk_unuse_block (wosc->wchunk, &wosc->block);
+  wosc->wchunk = wosc->config.wchunk_from_freq (wosc->config.wchunk_data, base_freq);
+  wosc->block.play_dir = wosc->config.play_dir;
+  wosc->block.offset = wosc->config.start_offset;
+  gsl_wave_chunk_use_block (wosc->wchunk, &wosc->block);
+  wosc->x = wosc->block.start + wosc->config.channel;
+
+  /*g_printerr ("wave lookup: want=%f got=%f length=%lu\n",
+	      base_freq, wosc->wchunk->osc_freq, wosc->wchunk->wave_length);*/
+
+  wosc->last_freq_level = GSL_SIGNAL_FROM_FREQ (base_freq);
+  wosc->last_mod_level = 0;
+  gsl_wave_osc_set_filter (wosc, base_freq, TRUE);
+}
+
+void
+gsl_wave_osc_config (GslWaveOscData   *wosc,
+		     GslWaveOscConfig *config)
+{
+  g_return_if_fail (wosc != NULL);
+  g_return_if_fail (config != NULL);
+
+  if (wosc->config.wchunk_data != config->wchunk_data ||
+      wosc->config.wchunk_from_freq != config->wchunk_from_freq ||
+      wosc->config.channel != config->channel)
+    {
+      if (wosc->wchunk)
+	gsl_wave_chunk_unuse_block (wosc->wchunk, &wosc->block);
+      wosc->wchunk = NULL;
+      wosc->config = *config;
+      gsl_wave_osc_retrigger (wosc, wosc->config.cfreq);
+    }
+  else
+    {
+      wosc->config.play_dir = config->play_dir;
+      wosc->config.fm_strength = config->fm_strength;
+      if (wosc->config.cfreq != config->cfreq ||
+	  wosc->config.start_offset != config->start_offset)
+	{
+	  wosc->config.start_offset = config->start_offset;
+	  wosc->config.cfreq = config->cfreq;
+	  gsl_wave_osc_retrigger (wosc, wosc->config.cfreq);
+	}
+    }
+}
+
+void
+gsl_wave_osc_init (GslWaveOscData *wosc)
+{
+  g_return_if_fail (wosc != NULL);
+
+  g_assert (GSL_WAVE_OSC_FILTER_ORDER <= gsl_get_config ()->wave_chunk_padding);
+
+  memset (wosc, 0, sizeof (GslWaveOscData));
+  wosc->mix_freq = gsl_engine_sample_freq ();
+}
+
+void
+gsl_wave_osc_shutdown (GslWaveOscData *wosc)
+{
+  g_return_if_fail (wosc != NULL);
+
+  if (wosc->wchunk)
+    gsl_wave_chunk_unuse_block (wosc->wchunk, &wosc->block);
+  memset (wosc, 0xaa, sizeof (GslWaveOscData));
+}
diff --git a/flow/gsl/gslwaveosc.h b/flow/gsl/gslwaveosc.h
new file mode 100644
index 0000000..c41b207
--- /dev/null
+++ b/flow/gsl/gslwaveosc.h
@@ -0,0 +1,96 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik and Stefan Westerfeld
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This library 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 Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+#ifndef __GSL_WAVE_OSC_H__
+#define __GSL_WAVE_OSC_H__
+
+#include <gsl/gsldefs.h>
+#include <gsl/gslwavechunk.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GSL_WAVE_OSC_FILTER_ORDER	(8)	/* <= GslConfig.wave_chunk_padding ! */
+
+typedef struct
+{
+  GslLong	  start_offset;
+  gint            play_dir, channel;
+
+  gpointer	  wchunk_data;
+  GslWaveChunk* (*wchunk_from_freq) (gpointer	wchunk_data,
+				     gfloat     freq);
+
+  gfloat	  fm_strength;	/* linear: 0..1, exponential: n_octaves */
+  guint		  exponential_fm : 1;
+  gfloat	  cfreq;	/* for ifreq == NULL */
+} GslWaveOscConfig;
+
+typedef struct
+{
+  GslWaveOscConfig  config;
+  guint		    last_mode;
+  gfloat	    last_sync_level, last_freq_level, last_mod_level;
+  GslWaveChunkBlock block;
+  gfloat           *x;                  /* pointer into block */
+  guint             cur_pos, istep;	/* FIXME */
+  gdouble           a[GSL_WAVE_OSC_FILTER_ORDER + 1];       /* order */
+  gdouble           b[GSL_WAVE_OSC_FILTER_ORDER + 1];       /* reversed order */
+  gdouble           y[GSL_WAVE_OSC_FILTER_ORDER + 1];
+  guint             j;                  /* y[] index */
+  GslWaveChunk     *wchunk;
+  gfloat	    mix_freq;		/* gsl_engine_sample_freq() */
+  gfloat	    step_factor;
+  gboolean	    done;		/* FIXME. caution, this is TRUE only if
+					 * (play_dir < 0 && cur_pos < 0) ||
+					 * (play_dir > 0 && cur_pos > wchunk.length)
+					 */
+} GslWaveOscData;
+
+
+void		gsl_wave_osc_config	(GslWaveOscData	*wosc,
+					 GslWaveOscConfig *config);
+gboolean	gsl_wave_osc_process	(GslWaveOscData	*wosc,
+					 guint		 n_values,
+					 const gfloat	*ifreq,
+					 const gfloat	*mod,
+					 const gfloat	*sync,
+					 gfloat		*mono_out);
+void		gsl_wave_osc_retrigger	(GslWaveOscData	*wosc,
+					 gfloat		 freq);
+void		gsl_wave_osc_set_filter	(GslWaveOscData	*wosc,
+					 gfloat		 freq,
+					 gboolean	 clear_state);
+
+void		gsl_wave_osc_init	(GslWaveOscData	*wosc);
+void		gsl_wave_osc_shutdown	(GslWaveOscData	*wosc);
+
+/* setup:
+ * wosc = g_new0 (GslWaveOscData, 1);
+ * wosc->mix_freq = gsl_engine_sample_freq ();
+ */
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __GSL_WAVE_OSC_H__ */
diff --git a/flow/gsl/gslwchunk.c b/flow/gsl/gslwchunk.c
new file mode 100644
index 0000000..1fa4d74
--- /dev/null
+++ b/flow/gsl/gslwchunk.c
@@ -0,0 +1,279 @@
+/* GSL - Generic Sound Layer
+ * Copyright (C) 2001-2002 Tim Janik
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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        "gslwavechunk.h"
+#include        "gsldatahandle.h"
+#include	<stdio.h>
+#include	<stdlib.h>
+#include	<string.h>
+#include	<unistd.h>
+#include	<sys/stat.h>
+#include	<fcntl.h>
+#include	<math.h>
+
+enum {
+  VERBOSITY_NONE,
+  VERBOSITY_SETUP,
+  VERBOSITY_BLOCKS,
+  VERBOSITY_DATA,
+  VERBOSITY_PADDING,
+  VERBOSITY_CHECKS,
+};
+static guint verbosity = VERBOSITY_SETUP;
+
+static gfloat my_data[] = {
+  0.555555555,1,2,3,4,5,6,7,8,9,
+  10,11,12,13,14,15,16,17,18,19,
+  20,21,22,23,24,25,26,27,28,29,
+  30,31,32,33,34,35,36,
+};
+static guint  my_data_length = sizeof (my_data) / sizeof (my_data[0]);
+
+static void	print_block (GslWaveChunk      *wchunk,
+			     GslWaveChunkBlock *block);
+
+#define DEBUG_SIZE	(1024 * 256)
+#define	MINI_DEBUG_SIZE	(16)
+
+static void
+run_tests (GslWaveLoopType loop_type,
+	   gint            play_dir,
+	   gint		   loop_first,
+	   gint		   loop_last,
+	   gint		   loop_count)
+{
+  gfloat tmpstorage[DEBUG_SIZE], *cmpblock = tmpstorage + DEBUG_SIZE / 2;
+  GslDataHandle *myhandle;
+  GslDataCache *dcache;
+  GslWaveChunkBlock block = { 0, 0 };
+  GslWaveChunk *wchunk;
+  GslErrorType error;
+
+  myhandle = gsl_data_handle_new_mem (1, 32, my_data_length, my_data, NULL);
+  dcache = gsl_data_cache_new (myhandle, 1);
+  gsl_data_handle_unref (myhandle);
+  wchunk = gsl_wave_chunk_new (dcache,
+			       44.0, 44100.0,
+			       loop_type, loop_first, loop_last, loop_count);
+  error = gsl_wave_chunk_open (wchunk);
+  if (error)
+    g_error ("failed to open wave chunk: %s", gsl_strerror (error));
+  gsl_wave_chunk_unref (wchunk);
+  if (verbosity >= VERBOSITY_SETUP)
+    g_print ("SETUP: loop_type=%u loop_first=%ld loop_last=%ld loop_count=%d playdir=%+d\n",
+	     wchunk->loop_type, wchunk->loop_first, wchunk->loop_last, wchunk->loop_count, play_dir);
+  gsl_wave_chunk_debug_block (wchunk, - DEBUG_SIZE / 2, DEBUG_SIZE, cmpblock - DEBUG_SIZE / 2);
+
+  block.play_dir = play_dir;
+
+  block.offset = block.play_dir < 0 ? wchunk->wave_length + MINI_DEBUG_SIZE/2 : -MINI_DEBUG_SIZE/2;
+  while (block.offset < wchunk->wave_length + MINI_DEBUG_SIZE &&
+	 block.offset > -MINI_DEBUG_SIZE)
+    {
+      gint i, start, end, abort;
+
+      gsl_wave_chunk_use_block (wchunk, &block);
+
+      print_block (wchunk, &block);
+      if (block.play_dir > 0)
+	{
+	  start = block.offset - wchunk->n_pad_values;
+	  end = block.offset + block.length + wchunk->n_pad_values;
+	}
+      else
+	{
+	  start = block.offset + wchunk->n_pad_values;
+	  end = block.offset - block.length - wchunk->n_pad_values;
+	}
+      abort = FALSE;
+      for (i = start; i != end; i += block.play_dir)
+	{
+	  gfloat v = (block.play_dir < 0) ^ (block.dirstride > 0) ? block.start[i - block.offset] : block.start[block.offset - i];
+
+	  if (fabs (cmpblock[i] - v) > 1e-15)
+	    {
+	      abort = TRUE;
+	      verbosity = 99;
+	    }
+	  if (verbosity >= VERBOSITY_CHECKS)
+	    g_print ("%s: offset=%d (block.offset=%ld) value=%.16f found=%.16f\n",
+		     fabs (cmpblock[i] - v) > 1e-15 ? "MISMATCH" : "match",
+		     i, (i - block.offset), cmpblock[i], v);
+	}
+      if (abort)
+	{
+	  g_error ("mismatches occoured, setup: loop_type=%u loop_first=%ld loop_last=%ld loop_count=%d (length=%ld)",
+		   wchunk->loop_type, wchunk->loop_first, wchunk->loop_last, wchunk->loop_count,
+		   gsl_data_handle_length (wchunk->dcache->dhandle));
+	}
+
+      gsl_wave_chunk_unuse_block (wchunk, &block);
+
+      block.offset = block.next_offset;
+      /* block.offset += block.play_dir; */
+    }
+  gsl_wave_chunk_close (wchunk);
+  gsl_data_cache_unref (dcache);
+}
+
+static void
+print_block (GslWaveChunk      *wchunk,
+	     GslWaveChunkBlock *block)
+{
+  gfloat *p = NULL;
+  guint i;
+
+  if (verbosity >= VERBOSITY_BLOCKS)
+    {
+      g_print ("BLOCK:");
+      g_print (" offset=%ld", block->offset);
+      g_print (" length=%ld", block->length);
+      g_print (" dirstride=%d", block->dirstride);
+    }
+
+  if (verbosity >= VERBOSITY_PADDING)
+    {
+      g_print (" {prepad:");
+      i = wchunk->n_pad_values;
+      p = block->start - (block->dirstride > 0 ? i : -i);
+      while (i--)
+	{
+	  g_print (" %.1f", *p);
+	  p += block->dirstride;
+	}
+      g_print ("}");
+    }
+
+  if (verbosity >= VERBOSITY_DATA)
+    {
+      g_print (" {data:");
+      p = block->start;
+      while (p != block->end)
+	{
+	  g_print (" %.1f", *p);
+	  p += block->dirstride;
+	}
+      g_print ("}");
+    }
+
+  if (verbosity >= VERBOSITY_PADDING)
+    {
+      i = wchunk->n_pad_values;
+      g_print (" {postpad:");
+      while (i--)
+	{
+	  g_print (" %.1f", *p);
+	  p += block->dirstride;
+	}
+      g_print ("}");
+    }
+
+  if (verbosity >= VERBOSITY_BLOCKS)
+    g_print ("\n");
+}
+
+int
+main (gint   argc,
+      gchar *argv[])
+{
+  GslConfigValue gslconfig[] = {
+    { "wave_chunk_padding",     1, },
+    { "wave_chunk_big_pad",     2, },
+    { "dcache_block_size",      16, },
+    { NULL, },
+  };
+  gint i, j, k;
+
+  if (!g_thread_supported ())
+    g_thread_init (NULL);
+  gsl_init (gslconfig, NULL);
+
+  if (1)
+    {
+      GslDataHandle *myhandle;
+      GslDataHandle *rhandle1, *rhandle2;
+      GslLong o, l, i, e;
+      GslErrorType error;
+
+      g_print ("reversed datahandle test:...\n");
+
+      myhandle = gsl_data_handle_new_mem (1, 32, my_data_length, my_data, NULL);
+      rhandle1 = gsl_data_handle_new_reverse (myhandle);
+      gsl_data_handle_unref (myhandle);
+      rhandle2 = gsl_data_handle_new_reverse (rhandle1);
+      gsl_data_handle_unref (rhandle1);
+      error = gsl_data_handle_open (rhandle2);
+      if (error)
+	g_error ("failed to open rhandle2: %s", gsl_strerror (error));
+      gsl_data_handle_unref (rhandle2);
+
+      g_assert (gsl_data_handle_length (rhandle2) == gsl_data_handle_length (myhandle));
+
+      for (i = 1; i < 8; i++)
+	{
+	  o = 0;
+	  l = gsl_data_handle_length (rhandle2);
+	  while (l)
+	    {
+	      gfloat d1[8], d2[8];
+
+	      e = gsl_data_handle_read (myhandle, o, MIN (i, l), d1);
+	      g_assert (e == MIN (i, l));
+	      e = gsl_data_handle_read (rhandle2, o, MIN (i, l), d2);
+	      g_assert (e == MIN (i, l));
+	      g_assert (memcmp (d1, d2, sizeof (d1[0]) * e) == 0);
+	      l -= e;
+	      o += e;
+	    }
+	}
+      gsl_data_handle_close (rhandle2);
+      g_print ("passed.\n");
+    }
+
+  if (1)
+    {
+      g_print ("primitive loop tests:...\n");
+
+      run_tests (GSL_WAVE_LOOP_NONE, -1, 0, 0, 0);
+
+      run_tests (GSL_WAVE_LOOP_NONE, 1, 0, 0, 0);
+      run_tests (GSL_WAVE_LOOP_NONE, -1, 0, 0, 0);
+      run_tests (GSL_WAVE_LOOP_JUMP, 1, 0, 0, 0);
+      run_tests (GSL_WAVE_LOOP_PINGPONG, 1, 0, 0, 0);
+      run_tests (GSL_WAVE_LOOP_JUMP, -1, 0, 0, 0);
+      run_tests (GSL_WAVE_LOOP_PINGPONG, -1, 0, 0, 0);
+      g_print ("passed.\n");
+    }
+
+  if (1)
+    {
+      g_print ("brute loop tests:...\n");
+      for (i = 1; i < 7; i++)
+	for (j = 0; j < my_data_length - 1; j++)
+	  for (k = j + 1; k < my_data_length; k++)
+	    {
+	      run_tests (GSL_WAVE_LOOP_JUMP, 1, j, k, i);
+	      run_tests (GSL_WAVE_LOOP_PINGPONG, 1, j, k, i);
+	      run_tests (GSL_WAVE_LOOP_JUMP, -1, j, k, i);
+	      run_tests (GSL_WAVE_LOOP_PINGPONG, -1, j, k, i);
+	    }
+      g_print ("passed.\n");
+    }
+
+  return 0;
+}
diff --git a/flow/gslpp/Makefile.am b/flow/gslpp/Makefile.am
new file mode 100644
index 0000000..11f7407
--- /dev/null
+++ b/flow/gslpp/Makefile.am
@@ -0,0 +1,7 @@
+INCLUDES = -I$(top_srcdir)/flow -I$(top_srcdir)/flow/gsl -I$(top_builddir)/flow -I$(top_srcdir)/mcop -I$(top_builddir)/mcop -I$(top_builddir) $(all_includes)
+
+noinst_LTLIBRARIES = libgslpp.la
+
+libgslpp_la_SOURCES = datahandle.cpp
+#libgslpp_la_LIBADD = $(top_builddir)/mcop/libmcop.la $(top_builddir)/flow/gsl/libgsl.la -lm $(LIBPOSIX4)
+#libgslpp_la_LDFLAGS = -no-undefined
diff --git a/flow/gslpp/datahandle.cpp b/flow/gslpp/datahandle.cpp
new file mode 100644
index 0000000..963e57e
--- /dev/null
+++ b/flow/gslpp/datahandle.cpp
@@ -0,0 +1,412 @@
+    /*
+
+    Copyright (C) 2002 Hans Meine
+                       hans_meine@gmx.net
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "datahandle.h"
+#include "../../mcop/debug.h"
+
+namespace GSL {
+
+void DataHandle::copyFrom(const DataHandle &other)
+{
+	handle_ = other.handle_;
+	if(handle_)
+		gsl_data_handle_ref(handle_);
+}
+
+DataHandle::DataHandle(GslDataHandle *handle)
+	: handle_(handle)
+{
+}
+
+DataHandle::DataHandle(const DataHandle &other) { copyFrom(other); }
+
+DataHandle &DataHandle::operator =(const DataHandle &other)
+{
+	if(!( other == *this )) {
+		if(handle_)
+			gsl_data_handle_unref(handle_);
+		copyFrom(other);
+	}
+	return *this;
+}
+
+bool DataHandle::operator ==(const DataHandle &other) const
+{
+	return handle_ == other.handle_;
+}
+
+bool DataHandle::isNull() const
+{
+	return handle_ == 0;
+}
+
+DataHandle::~DataHandle()
+{
+	if(handle_)
+		gsl_data_handle_unref(handle_);
+}
+
+gint DataHandle::open()
+{
+	arts_return_val_if_fail(handle_ != 0, -1);
+
+	arts_debug("open()ing datahandle (open_count before: %d)..",
+			   handle_->open_count);
+
+	return gsl_data_handle_open(handle_);
+}
+
+void DataHandle::close()
+{
+	arts_return_if_fail(handle_ != 0);
+
+	arts_debug("close()ing datahandle (open_count before: %d)..",
+			   handle_->open_count);
+
+	gsl_data_handle_close(handle_);
+}
+
+bool DataHandle::isOpen() const
+{
+	if(!handle_)
+		return false;
+
+	return handle_->open_count != 0;
+}
+
+GslLong DataHandle::read(GslLong valueOffset, GslLong valueCount, gfloat *values)
+{
+	arts_return_val_if_fail(handle_ != 0, 0);
+
+	return gsl_data_handle_read(handle_, valueOffset, valueCount, values);
+}
+
+DataHandle DataHandle::createCropped(GslLong headCutValueCount,
+									 GslLong tailCutValueCount)
+{
+	arts_return_val_if_fail(handle_ != 0, null());
+
+	return DataHandle(gsl_data_handle_new_crop(handle_,
+											   headCutValueCount, tailCutValueCount));
+}
+
+DataHandle DataHandle::createCut(GslLong cutOffset,
+								 GslLong cutValueCount)
+{
+	arts_return_val_if_fail(handle_ != 0, null());
+
+	return DataHandle(gsl_data_handle_new_cut(handle_, cutOffset,
+											  cutValueCount));
+}
+
+DataHandle DataHandle::createReversed()
+{
+	arts_return_val_if_fail(handle_ != 0, null());
+
+	return DataHandle(gsl_data_handle_new_reverse(handle_));
+}
+
+GslDataCache *DataHandle::createGslDataCache()
+{
+	arts_debug("wanna have cache with padding %d for each of %d channels..",
+			   gsl_get_config()->wave_chunk_padding,
+			   channelCount());
+	return gsl_data_cache_from_dhandle(handle_,
+									   gsl_get_config()->wave_chunk_padding *
+									   channelCount());
+}
+
+GslLong DataHandle::valueCount() const
+{
+	arts_return_val_if_fail(handle_ != 0, 0);
+	arts_return_val_if_fail(isOpen(), 0);
+
+	return handle_->setup.n_values;
+}
+
+guint DataHandle::channelCount() const
+{
+	arts_return_val_if_fail(handle_ != 0, 0);
+	arts_return_val_if_fail(isOpen(), 0);
+
+	return handle_->setup.n_channels;
+}
+
+guint DataHandle::bitDepth() const
+{
+	arts_return_val_if_fail(handle_ != 0, 0);
+	arts_return_val_if_fail(isOpen(), 0);
+
+	return handle_->setup.bit_depth;
+}
+
+// ----------------------------------------------------------------------------
+
+WaveChunkDescription::WaveChunkDescription(const GslWaveDsc *parent, guint index)
+	: parent_(parent), parentIndex_(index)
+{
+	if(index>parent->n_chunks)
+	{
+		arts_debug("wrong index given to WaveChunkDescription constructor, "
+				   "using 0 instead..");
+		parentIndex_ = 0;
+	}
+}
+
+float WaveChunkDescription::oscillatorFrequency()
+{
+	return parent_->chunks[parentIndex_].osc_freq;
+}
+
+float WaveChunkDescription::mixerFrequency()
+{
+	return parent_->chunks[parentIndex_].mix_freq;
+}
+
+GslWaveLoopType WaveChunkDescription::loopType()
+{
+	return parent_->chunks[parentIndex_].loop_type;
+}
+
+GslLong WaveChunkDescription::loopStart()
+{
+	return parent_->chunks[parentIndex_].loop_start;
+}
+
+GslLong WaveChunkDescription::loopEnd()
+{
+	return parent_->chunks[parentIndex_].loop_end;
+}
+
+guint WaveChunkDescription::loopCount()
+{
+	return parent_->chunks[parentIndex_].loop_count;
+}
+
+WaveDataHandle WaveChunkDescription::createDataHandle()
+{
+	return WaveDataHandle(parent_, parentIndex_);
+}
+
+// ----------------------------------------------------------------------------
+
+/**
+ * We use GslWaveFileInfos' refcounting - probably this lazy
+ * construction happens only once, where the object is used. After
+ * copying it would have to be constructed again, but that's not
+ * likely to happen. (?)
+ */
+void WaveDescription::ensurePointer() const
+{
+	if(!desc_)
+		desc_ = gsl_wave_dsc_load(parentInfo_, parentIndex_, &error_);
+}
+
+void WaveDescription::copyFrom(const WaveDescription &other)
+{
+	parentInfo_ = other.parentInfo_;
+	parentIndex_ = other.parentIndex_;
+	gsl_wave_file_info_ref(other.parentInfo_);
+}
+
+// internal, private
+WaveDescription::WaveDescription(GslWaveFileInfo *parent, guint index,
+								 const std::string &name)
+	: parentInfo_(parent), name_(name), parentIndex_(index),
+	  desc_(0), error_(GSL_ERROR_NONE)
+{
+	gsl_wave_file_info_ref(parentInfo_);
+}
+
+WaveDescription::~WaveDescription()
+{
+	if(desc_)
+		gsl_wave_dsc_free(desc_);
+	gsl_wave_file_info_unref(parentInfo_);
+}
+
+WaveDescription::WaveDescription(const WaveDescription &other)
+	: desc_(0), error_(GSL_ERROR_NONE)
+{
+	copyFrom(other);
+}
+
+WaveDescription &WaveDescription::operator =(const WaveDescription &other)
+{
+	if(desc_)
+		gsl_wave_dsc_free(desc_);
+	gsl_wave_file_info_unref(parentInfo_);
+	copyFrom(other);
+	return *this;
+}
+
+const std::string &WaveDescription::name() const
+{
+	return name_;
+}
+
+GslErrorType WaveDescription::error() const
+{
+	ensurePointer();
+	return error_;
+}
+
+guint WaveDescription::chunkCount() const
+{
+	ensurePointer();
+	return desc_ ? desc_->n_chunks : 0;
+}
+
+WaveChunkDescription WaveDescription::chunkDescription(guint index) const
+{
+	ensurePointer();
+	return WaveChunkDescription(desc_, index);
+}
+
+guint WaveDescription::channelCount() const
+{
+	ensurePointer();
+	return desc_ ? desc_->n_channels : 0;
+}
+
+// ----------------------------------------------------------------------------
+
+void WaveFileInfo::copyFrom(const WaveFileInfo &other)
+{
+	info_ = other.info_;
+	filename_ = other.filename_;
+	if(info_)
+		gsl_wave_file_info_ref(info_);
+
+	error_ = other.error_;
+}
+
+WaveFileInfo::WaveFileInfo(const std::string &filename)
+	: info_(0), error_(GSL_ERROR_NONE), filename_(filename)
+{
+	info_ = gsl_wave_file_info_load(filename.c_str(), &error_);
+}
+
+WaveFileInfo::~WaveFileInfo()
+{
+	if(info_)
+		gsl_wave_file_info_unref(info_);
+}
+
+WaveFileInfo::WaveFileInfo(const WaveFileInfo &other)
+{
+	copyFrom(other);
+}
+
+WaveFileInfo &WaveFileInfo::operator =(const WaveFileInfo &other)
+{
+	if(info_)
+		gsl_wave_file_info_unref(info_);
+	copyFrom(other);
+	return *this;
+}
+
+guint WaveFileInfo::waveCount() const
+{
+	return info_ ? info_->n_waves : 0;
+}
+
+std::string WaveFileInfo::waveName(guint index) const
+{
+	if(index >= waveCount())
+		return "";
+	return info_->waves[index].name;
+}
+
+WaveDescription WaveFileInfo::waveDescription(guint index)
+{
+	return WaveDescription(info_, index, waveName(index));
+}
+
+GslErrorType WaveFileInfo::error() const
+{
+	return error_;
+}
+
+// ----------------------------------------------------------------------------
+
+WaveDataHandle::WaveDataHandle()
+	: DataHandle(NULL),
+	  oscillatorFrequency_(0),
+	  mixerFrequency_(0)
+{
+}
+
+WaveDataHandle::WaveDataHandle(const GslWaveDsc *waveDesc, guint chunkIndex)
+	: DataHandle(NULL),
+	  oscillatorFrequency_(0),
+	  mixerFrequency_(0)
+{
+	handle_ = gsl_wave_handle_create(const_cast<GslWaveDsc *>(waveDesc),
+									 chunkIndex, &error_);
+	if(error() == GSL_ERROR_NONE)
+	{
+		oscillatorFrequency_ = waveDesc->chunks[chunkIndex].osc_freq;
+		mixerFrequency_ = waveDesc->chunks[chunkIndex].mix_freq;
+	}
+}
+
+WaveDataHandle::WaveDataHandle(const std::string& filename,
+							   guint waveIndex,
+							   guint chunkIndex)
+	: DataHandle(NULL),
+	  oscillatorFrequency_(0),
+	  mixerFrequency_(0)
+{
+	GSL::WaveFileInfo info(filename);
+	error_ = info.error();
+
+	if(!info.error())
+	{
+		GSL::WaveDescription desc= info.waveDescription(waveIndex);
+		error_ = desc.error();
+
+		if(!desc.error() && (desc.chunkCount() > chunkIndex))
+		{
+			GSL::WaveChunkDescription chunkDesc= desc.chunkDescription(chunkIndex);
+
+			(*this) = chunkDesc.createDataHandle();
+		}
+	}
+}
+
+GslErrorType WaveDataHandle::error() const
+{
+	return error_;
+}
+
+float WaveDataHandle::oscillatorFrequency() const
+{
+	return oscillatorFrequency_;
+}
+
+float WaveDataHandle::mixerFrequency() const
+{
+	return mixerFrequency_;
+}
+
+}
diff --git a/flow/gslpp/datahandle.h b/flow/gslpp/datahandle.h
new file mode 100644
index 0000000..7cab930
--- /dev/null
+++ b/flow/gslpp/datahandle.h
@@ -0,0 +1,220 @@
+    /*
+
+    Copyright (C) 2002 Hans Meine
+                       hans_meine@gmx.net
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef GSLPP_DATAHANDLE_H
+#define GSLPP_DATAHANDLE_H
+
+#include <gsl/gsldatahandle.h>
+#include <gsl/gslloader.h>
+#include <string>
+
+namespace GSL
+{
+	class WaveFileInfo;
+	class WaveDataHandle;
+	class WaveDescription;
+
+	class DataHandle
+	{
+	protected:
+		GslDataHandle *handle_;
+
+		void clearHandle();
+		void copyFrom(const DataHandle &other);
+
+		DataHandle(GslDataHandle *handle);
+
+	public:
+		static DataHandle null() { return DataHandle(); }
+
+		DataHandle(): handle_(0) {}
+
+		DataHandle(const DataHandle &other);
+
+		DataHandle &operator =(const DataHandle &other);
+
+		bool operator ==(const DataHandle &other) const;
+
+		bool isNull() const;
+
+		virtual ~DataHandle();
+
+		/**
+		 * returns error code with errno meaning
+		 */
+		virtual gint open();
+
+		virtual void close();
+
+		bool isOpen() const;
+
+		/**
+		 * read from this datahandle and fill buffer pointed to by
+		 * values with sample data from the range
+		 * [valueOffset..valueOffset+valueCount-1]
+		 *
+		 * returns number of sample values actually read, -1 on error
+		 * (errno _may_ be useful then)
+		 */
+		virtual GslLong read(GslLong valueOffset, GslLong valueCount, gfloat *values);
+
+		/**
+		 * Create a new data handle by chopping off headCutValueCount
+		 * values at the start, and tailCutValueCount values at the
+		 * end of this data handle.
+		 */
+		DataHandle createCropped(GslLong headCutValueCount,
+								 GslLong tailCutValueCount);
+
+		/**
+		 * Create a new data handle by removing the values
+		 * [cutOffset..cutOffset+cutValueCount-1].
+		 */
+		DataHandle createCut(GslLong cutOffset,
+							 GslLong cutValueCount);
+
+		/**
+		 * Create a new data handle which contains the same values as
+		 * this one but in reversed order.
+		 */
+		DataHandle createReversed();
+
+		// this will maybe be made private in the future, having a
+		// better interface instead
+		GslDataCache *createGslDataCache();
+
+		GslLong valueCount() const;
+
+		guint bitDepth() const;
+
+		guint channelCount() const;
+	};
+
+	class WaveChunkDescription
+	{
+		friend class WaveDescription;
+
+		const GslWaveDsc    *parent_;
+		guint                parentIndex_;
+
+		WaveChunkDescription(const GslWaveDsc *parent, guint index);
+
+	public:
+		float oscillatorFrequency();
+		float mixerFrequency();
+
+		GslWaveLoopType loopType();
+		GslLong loopStart();	/* sample offset */
+		GslLong loopEnd();	/* sample offset */
+		guint loopCount();
+
+		WaveDataHandle createDataHandle();
+	};
+
+	class WaveDescription
+	{
+		friend class WaveFileInfo; // for construction of WaveDescriptions
+
+		mutable GslWaveFileInfo    *parentInfo_;  // mutable for ensurePointer()
+		std::string                 name_;
+		guint                       parentIndex_;
+		mutable GslWaveDsc         *desc_;
+		mutable GslErrorType        error_;
+
+		void ensurePointer() const; // lazy construction
+
+		void copyFrom(const WaveDescription &other);
+
+		WaveDescription(GslWaveFileInfo *parent, guint index, const std::string &name);
+
+	public:
+		~WaveDescription();
+
+		WaveDescription(const WaveDescription &other);
+
+		WaveDescription &operator =(const WaveDescription &other);
+
+		const std::string &name() const;
+
+		GslErrorType error() const;
+
+		guint chunkCount() const;
+
+		WaveChunkDescription chunkDescription(guint index) const;
+
+		guint channelCount() const;
+	};
+
+	class WaveFileInfo
+	{
+		GslWaveFileInfo *info_;
+		GslErrorType     error_;
+		std::string      filename_;
+
+		void copyFrom(const WaveFileInfo &other);
+
+	public:
+		WaveFileInfo(const std::string &filename);
+
+		~WaveFileInfo();
+
+		WaveFileInfo(const WaveFileInfo &other);
+
+		WaveFileInfo &operator =(const WaveFileInfo &other);
+
+		guint waveCount() const;
+
+		std::string waveName(guint index) const;
+
+		WaveDescription waveDescription(guint index);
+
+		GslErrorType error() const;
+	};
+
+	class WaveDataHandle: public DataHandle
+	{
+		friend class WaveChunkDescription;
+
+		GslErrorType     error_;
+
+		float oscillatorFrequency_;
+		float mixerFrequency_;
+
+		WaveDataHandle();
+		WaveDataHandle(const GslWaveDsc *waveDesc, guint chunkIndex = 0);
+
+	public:
+		WaveDataHandle(const std::string& filename,
+					   guint waveIndex = 0,
+					   guint chunkIndex = 0);
+
+		static WaveDataHandle null() { return WaveDataHandle(); }
+
+		GslErrorType error() const;
+
+		float oscillatorFrequency() const;
+
+		float mixerFrequency() const;
+	};
+}
+
+#endif // GSLPP_DATAHANDLE_H
diff --git a/flow/gslschedule.cc b/flow/gslschedule.cc
new file mode 100644
index 0000000..370bac1
--- /dev/null
+++ b/flow/gslschedule.cc
@@ -0,0 +1,1195 @@
+    /*
+
+    Copyright (C) 2000-2002 Stefan Westerfeld
+                            stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "config.h"
+
+#include "virtualports.h"
+#include "startupmanager.h"
+#include "gslschedule.h"
+#include "debug.h"
+#include "asyncschedule.h"
+#include "audiosubsys.h"
+#include <gsl/gslcommon.h>
+#include <gsl/gslengine.h>
+#include <algorithm>
+#include <stdio.h>
+#include <iostream>
+#include <stack>
+
+/* HACK */
+class GslMainLoop {
+protected:
+	std::list<GslClass *> freeClassList;
+
+public:
+	GslEngineLoop loop;
+
+	static bool waitOnTransNeedData;
+	static bool gslDataCalculated;
+
+	/* static check function */
+	static gboolean gslCheck(gpointer /* data */, guint /* n_values */,
+							 glong*  /* timeout_p */,
+                         	 guint /* n_fds */, const GPollFD* /* fds */,
+						 	 gboolean /* revents_filled */)
+	{
+		return waitOnTransNeedData;
+	}
+	/* mainloop integration: initialize (called to get initial loop setup) */
+	void initialize()
+	{
+		gsl_transact(gsl_job_add_poll (gslCheck, 0, 0, 0, 0), 0);
+		gsl_engine_prepare(&loop);
+
+		for(unsigned int i = 0; i != loop.n_fds; i++)
+		{
+			printf("TODO: engine fd %d\n",i);
+		}
+	}
+	/* mainloop integration: process (TODO - should be called by IOManager) */
+	void process()
+	{
+		printf("TODO: mainloop wrapper for fd watches\n");
+		if(gsl_engine_check(&loop))
+			gsl_engine_dispatch();
+	}
+	/* wait for a transaction */
+	void waitOnTrans()
+	{
+		arts_return_if_fail(waitOnTransNeedData == false);
+		gsl_engine_wait_on_trans();
+	}
+	/* make the engine calculate something */
+	void run()
+	{
+		waitOnTransNeedData = true;
+		gslDataCalculated = false;
+
+		while(!gslDataCalculated && gsl_engine_check(&loop))
+			gsl_engine_dispatch();
+
+		gslDataCalculated = false;
+		waitOnTransNeedData = false;
+
+		if(!freeClassList.empty())
+		{
+			/*
+			 * make sure that all transactions that are still pending
+			 * get finished (especially important in threaded case,
+			 * since an entry in the free list doesn't necessarily
+			 * mean that the module has entierly been freed)
+			 */
+			waitOnTrans();
+
+			std::list<GslClass *>::iterator fi;
+			for(fi = freeClassList.begin(); fi != freeClassList.end(); fi++)
+				free(*fi);
+
+			freeClassList.clear();
+		}
+	}
+	void freeGslClass(GslClass *klass)
+	{
+		freeClassList.push_back(klass);
+	}
+} gslMainLoop;
+
+bool GslMainLoop::waitOnTransNeedData = false;
+bool GslMainLoop::gslDataCalculated = false;
+namespace Arts { extern void *gslGlobalMutexTable; }
+
+
+using namespace std;
+using namespace Arts;
+
+// ----------- Port -----------
+
+Port::Port(const string& name, void *ptr, long flags, StdScheduleNode* parent)
+	: _name(name), _ptr(ptr), _flags((AttributeType)flags),
+	  parent(parent), _dynamicPort(false)
+{
+	_vport = new VPort(this);
+}
+
+Port::~Port()
+{
+	if(_vport)
+		delete _vport;
+}
+
+AttributeType Port::flags()
+{
+	return _flags;
+}
+
+string Port::name()
+{
+	return _name;
+}
+
+ASyncPort *Port::asyncPort()
+{
+	return 0;
+}
+
+AudioPort *Port::audioPort()
+{
+	return 0;
+}
+
+void Port::addAutoDisconnect(Port *source)
+{
+	autoDisconnect.push_back(source);
+	source->autoDisconnect.push_back(this);
+}
+
+void Port::removeAutoDisconnect(Port *source)
+{
+	std::list<Port *>::iterator adi;
+
+	// remove our autodisconnection entry for source port
+	adi = find(autoDisconnect.begin(),autoDisconnect.end(),source);
+	assert(adi != autoDisconnect.end());
+	autoDisconnect.erase(adi);
+
+	// remove the source port autodisconnection entry to us
+	adi=find(source->autoDisconnect.begin(),source->autoDisconnect.end(),this);
+	assert(adi != source->autoDisconnect.end());
+	source->autoDisconnect.erase(adi);
+}
+
+void Port::disconnectAll()
+{
+	if(_vport)
+		delete _vport;
+	_vport = 0;
+	assert(autoDisconnect.empty());
+	while(!autoDisconnect.empty())
+	{
+		Port *other = *autoDisconnect.begin();
+
+		// syntax is disconnect(source)
+		if(_flags & streamIn)
+			// if we're incoming, other port is source
+			vport()->disconnect(other->vport());
+		else
+			// if we're outgoing, we're the source
+			other->vport()->disconnect(this->vport());
+	}
+}
+
+void Port::setPtr(void *ptr)
+{
+	_ptr = ptr;
+}
+
+// ------- AudioPort ---------
+
+AudioPort::AudioPort(const string& name,
+		             void *ptr, long flags,StdScheduleNode *parent)
+		: Port(name,ptr,flags,parent)
+{
+	destcount = 0;
+	sourcemodule = 0;
+	source = 0;
+	gslIsConstant = false;
+}
+
+AudioPort::~AudioPort()
+{
+	//
+}
+
+AudioPort *AudioPort::audioPort()
+{
+	return this;
+}
+
+void AudioPort::setFloatValue(float f)
+{
+	gslIsConstant = true;
+	gslConstantValue = f;
+
+	parent->_connectionCountChanged = true;
+}
+
+void AudioPort::connect(Port *psource)
+{
+	if (source) return; // Error, should not happen (See BR70028)
+	source = psource->audioPort();
+	assert(source);
+	addAutoDisconnect(psource);
+
+	source->parent->_connectionCountChanged = parent->_connectionCountChanged = true;
+	source->destcount++;
+	sourcemodule = source->parent;
+
+	// GSL connect
+	GslTrans *trans = gsl_trans_open();
+	gsl_trans_add(trans, gsl_job_connect(source->parent->gslModule,
+										 source->gslEngineChannel,
+										 parent->gslModule,
+										 gslEngineChannel));
+	gsl_trans_commit(trans);
+}
+
+void AudioPort::disconnect(Port *psource)
+{
+	if (!source || source != psource->audioPort()) return; // Error, should not happen (See BR70028)
+	assert(source);
+	assert(source == psource->audioPort());
+	removeAutoDisconnect(psource);
+
+	assert(sourcemodule == source->parent);
+	sourcemodule = 0;
+
+	source->parent->_connectionCountChanged = parent->_connectionCountChanged = true;
+	source->destcount--;
+	source = 0;
+
+	// GSL disconnect
+	GslTrans *trans = gsl_trans_open();
+	gsl_trans_add(trans, gsl_job_disconnect(parent->gslModule,
+										    gslEngineChannel));
+	gsl_trans_commit(trans);
+}
+
+// --------- MultiPort ----------
+
+MultiPort::MultiPort(const string& name,
+		             void *ptr, long flags,StdScheduleNode *parent)
+	: Port(name,ptr,flags,parent)
+{
+	conns = 0;
+	nextID = 0;
+	initConns();
+}
+
+MultiPort::~MultiPort()
+{
+	if(conns)
+	{
+		delete[] conns;
+		conns = 0;
+	}
+}
+
+void MultiPort::initConns()
+{
+	if(conns != 0) delete[] conns;
+	conns = new float_ptr[parts.size() + 1];
+	conns[parts.size()] = (float *)0;
+
+	*(float ***)_ptr = conns;
+
+	long n = 0;
+	std::list<Part>::iterator i;
+	for(i = parts.begin();i != parts.end(); i++)
+	{
+		AudioPort *p = i->dest;
+		p->setPtr((void *)&conns[n++]);
+	}
+}
+
+void MultiPort::connect(Port *port)
+{
+	AudioPort *dport;
+	char sid[20];
+	sprintf(sid,"%ld",nextID++);
+
+	addAutoDisconnect(port);
+
+	dport = new AudioPort("_"+_name+string(sid),0,streamIn,parent);
+
+	Part part;
+	part.src = (AudioPort *)port;
+	part.dest = dport;
+
+	parts.push_back(part);
+	initConns();
+
+	parent->addDynamicPort(dport);
+	dport->vport()->connect(port->vport());
+}
+
+void MultiPort::disconnect(Port *sport)
+{
+	AudioPort *port = (AudioPort *)sport;
+	removeAutoDisconnect(sport);
+
+	std::list<Part>::iterator i;
+	for(i = parts.begin(); i != parts.end(); i++)
+	{
+		if(i->src == port)
+		{
+			AudioPort *dport = i->dest;
+			parts.erase(i);
+			initConns();
+
+			dport->vport()->disconnect(port->vport());
+			parent->removeDynamicPort(dport);
+
+			delete dport;
+			return;
+		}
+	}
+}
+
+// -------- StdScheduleNode ---------
+
+void StdScheduleNode::freeConn()
+{
+	if(inConn)
+	{
+		delete[] inConn;
+		inConn = 0;
+	}
+	if(outConn)
+	{
+		delete[] outConn;
+		outConn = 0;
+	}
+	inConnCount = outConnCount = 0;
+
+	if(gslModule)
+	{
+		gsl_transact(gsl_job_discard(gslModule),0);
+
+		gslModule = 0;
+		gslRunning = false;
+	}
+}
+
+void StdScheduleNode::gslProcess(GslModule *module, guint n_values)
+{
+	StdScheduleNode *node = (StdScheduleNode *)module->user_data;
+	if(!node->running)		/* FIXME: need reasonable suspend in the engine */
+		return;
+
+	arts_return_if_fail(node->module != 0);
+
+	GslMainLoop::gslDataCalculated = true;
+
+	unsigned long j;
+	for(j=0;j<node->inConnCount;j++)
+	{
+		if(node->inConn[j]->gslIsConstant)
+			*((float **)node->inConn[j]->_ptr) =
+				gsl_engine_const_values(node->inConn[j]->gslConstantValue);
+		else
+			*((float **)node->inConn[j]->_ptr) = const_cast<float *>(module->istreams[j].values);
+	}
+
+	for(j=0;j<node->outConnCount;j++)
+		*((float **)node->outConn[j]->_ptr) = module->ostreams[j].values;
+
+	node->module->calculateBlock(n_values);
+}
+
+static void gslModuleFree(gpointer /* data */, const GslClass *klass)
+{
+	gslMainLoop.freeGslClass(const_cast<GslClass *>(klass));
+}
+
+void StdScheduleNode::rebuildConn()
+{
+	std::list<Port *>::iterator i;
+
+	freeConn();
+
+	inConnCount = outConnCount = 0;
+	inConn = new AudioPort_ptr[ports.size()];
+	outConn = new AudioPort_ptr[ports.size()];
+
+	for(i=ports.begin();i != ports.end();i++)
+	{
+		AudioPort *p = (*i)->audioPort();
+		if(p)
+		{
+			if(p->flags() & streamIn)
+			{
+				p->gslEngineChannel = inConnCount;
+				inConn[inConnCount++] = p;
+			}
+			if(p->flags() & streamOut)
+			{
+				p->gslEngineChannel = outConnCount;
+				outConn[outConnCount++] = p;
+			}
+		}
+	}
+
+	/* create GSL node */
+	GslClass *gslClass = (GslClass *)calloc(sizeof(GslClass),1);
+	gslClass->n_istreams = inConnCount;
+	gslClass->n_ostreams = outConnCount;
+	gslClass->process = gslProcess;
+	gslClass->free = gslModuleFree;
+
+	gslModule = gsl_module_new (gslClass, (StdScheduleNode *)this);
+
+	GslTrans *trans = gsl_trans_open();
+	gsl_trans_add(trans,gsl_job_integrate(gslModule));
+	gsl_trans_add(trans,gsl_job_set_consumer(gslModule, running));
+	gslRunning = running;
+
+	/* since destroying the old module and creating a new one will destroy
+	 * all the connections, we need to restore them here
+	 */
+	unsigned int c;
+	for(c = 0; c < inConnCount; c++)
+	{
+		if(inConn[c]->source)
+		{
+			gsl_trans_add(trans,
+				gsl_job_connect(inConn[c]->source->parent->gslModule,
+						 	 	inConn[c]->source->gslEngineChannel,
+								inConn[c]->parent->gslModule,
+								inConn[c]->gslEngineChannel));
+		}
+	}
+	for(c = 0; c < outConnCount; c++)
+	{
+		std::list<Port *>::iterator ci;
+
+		for(ci = outConn[c]->autoDisconnect.begin();
+			ci != outConn[c]->autoDisconnect.end(); ci++)
+		{
+			AudioPort *dest = (*ci)->audioPort();
+			if( dest )
+			{
+				gsl_trans_add(trans,
+					gsl_job_connect(outConn[c]->parent->gslModule,
+									outConn[c]->gslEngineChannel,
+									dest->parent->gslModule,
+									dest->gslEngineChannel));
+			}
+			else
+			{
+				arts_debug( "no audio port: %s for %s", ( *ci )->name().c_str(), _object->_interfaceName().c_str() );
+			}
+		}
+	}
+	gsl_trans_commit(trans);
+}
+
+Object_skel *StdScheduleNode::object()
+{
+	return _object;
+}
+
+void *StdScheduleNode::cast(const string &target)
+{
+	if(target == "StdScheduleNode") return (StdScheduleNode *)this;
+	return 0;
+}
+
+
+void StdScheduleNode::accessModule()
+{
+	if(module) return;
+
+	module = (SynthModule_base *)_object->_cast(Arts::SynthModule_base::_IID);
+	if(!module)
+		arts_warning("Error using interface %s in the flowsystem: only objects"
+					 " implementing Arts::SynthModule should carry streams.",
+					 _object->_interfaceName().c_str());
+}
+
+StdScheduleNode::StdScheduleNode(Object_skel *object, StdFlowSystem *flowSystem) : ScheduleNode(object)
+{
+	_object = object;
+	this->flowSystem = flowSystem;
+	running = false;
+	suspended = false;
+	module = 0;
+	gslModule = 0;
+	gslRunning = false;
+	queryInitStreamFunc = 0;
+	inConn = outConn = 0;
+	inConnCount = outConnCount = 0;
+}
+
+StdScheduleNode::~StdScheduleNode()
+{
+	/* stop module if still running */
+	if(running) stop();
+	/* disconnect all ports */
+	stack<Port *> disconnect_stack;
+
+	/*
+	 * we must be a bit careful here, as dynamic ports (which are created
+	 * for connections by MultiPorts) will suddenly start disappearing, so
+	 * we better make a copy of those ports that will stay, and disconnect
+	 * them then
+	 */
+	std::list<Port *>::iterator i;
+	for(i=ports.begin();i != ports.end();i++)
+	{
+		if(!(*i)->dynamicPort()) disconnect_stack.push(*i);
+	}
+
+	while(!disconnect_stack.empty())
+	{
+		disconnect_stack.top()->disconnectAll();
+		disconnect_stack.pop();
+	}
+	/* free them */
+	for(i=ports.begin();i != ports.end();i++)
+		delete (*i);
+	ports.clear();
+
+	freeConn();
+}
+
+void StdScheduleNode::initStream(const string& name, void *ptr, long flags)
+{
+	if(flags == -1)
+	{
+		queryInitStreamFunc = (QueryInitStreamFunc)ptr;
+	}
+	else if(flags & streamAsync)
+	{
+		ports.push_back(new ASyncPort(name,ptr,flags,this));
+	}
+	else if(flags & streamMulti)
+	{
+		ports.push_back(new MultiPort(name,ptr,flags,this));
+	}
+	else
+	{
+		ports.push_back(new AudioPort(name,ptr,flags,this));
+	}
+
+	// TODO: maybe initialize a bit later
+	rebuildConn();
+}
+
+void StdScheduleNode::addDynamicPort(Port *port)
+{
+	port->setDynamicPort();
+	ports.push_back(port);
+	rebuildConn();
+}
+
+void StdScheduleNode::removeDynamicPort(Port *port)
+{
+	std::list<Port *>::iterator i;
+	for(i=ports.begin();i!=ports.end();i++)
+	{
+		Port *p = *i;
+		if(p->name() == port->name())
+		{
+			ports.erase(i);
+			rebuildConn();
+			return;
+		}
+	}
+}
+
+void StdScheduleNode::start()
+{
+	assert(!running);
+	running = true;
+
+	//cout << "start" << endl;
+	accessModule();
+	module->streamInit();
+	module->streamStart();
+	flowSystem->startedChanged();
+}
+
+void StdScheduleNode::stop()
+{
+	assert(running);
+	running = false;
+
+	accessModule();
+	module->streamEnd();
+	flowSystem->startedChanged();
+}
+
+void StdScheduleNode::requireFlow()
+{
+	// cout << "rf" << module->_interfaceName() << endl;
+	flowSystem->updateStarted();
+	gslMainLoop.run();
+}
+
+AutoSuspendState StdScheduleNode::suspendable()
+{
+	if(running) {
+		accessModule();
+		return module->autoSuspend();
+	}
+	// if its not running, who cares?
+	return asSuspend;
+}
+
+void StdScheduleNode::suspend()
+{
+	if(running) {
+		accessModule();
+		suspended = true;
+		if((module->autoSuspend() & asSuspendMask) == asSuspendStop) stop();
+	}
+}
+
+void StdScheduleNode::restart()
+{
+	if(suspended) {
+		accessModule();
+		suspended = false;
+		if(!running && (module->autoSuspend() & asSuspendMask) == asSuspendStop) start();
+	}
+}
+
+Port *StdScheduleNode::findPort(const string& name)
+{
+	std::list<Port *>::iterator i;
+	for(i=ports.begin();i!=ports.end();i++)
+	{
+		Port *p = *i;
+		if(p->name() == name) return p;
+	}
+	if(queryInitStreamFunc)
+	{
+		if(queryInitStreamFunc(_object,name))
+		{
+			for(i=ports.begin();i!=ports.end();i++)
+			{
+				Port *p = *i;
+				if(p->name() == name) return p;
+			}
+		}
+	}
+	return 0;
+}
+
+void StdScheduleNode::virtualize(const std::string& port,
+		                         ScheduleNode *implNode,
+								 const std::string& implPort)
+{
+	StdScheduleNode *impl=(StdScheduleNode *)implNode->cast("StdScheduleNode");
+	if(impl)
+	{
+		Port *p1 = findPort(port);
+		Port *p2 = impl->findPort(implPort);
+
+		assert(p1);
+		assert(p2);
+		p1->vport()->virtualize(p2->vport());
+	}
+}
+
+void StdScheduleNode::devirtualize(const std::string& port,
+		                           ScheduleNode *implNode,
+								   const std::string& implPort)
+{
+	StdScheduleNode *impl=(StdScheduleNode *)implNode->cast("StdScheduleNode");
+	if(impl)
+	{
+		Port *p1 = findPort(port);
+		Port *p2 = impl->findPort(implPort);
+
+		p1->vport()->devirtualize(p2->vport());
+	}
+}
+
+void StdScheduleNode::connect(const string& port, ScheduleNode *dest,
+		                                          const string& destport)
+{
+	RemoteScheduleNode *rsn = dest->remoteScheduleNode();
+	if(rsn)
+	{
+		// RemoteScheduleNodes know better how to connect remotely
+		rsn->connect(destport,this,port);
+		return;
+	}
+
+	flowSystem->restart();
+
+	Port *p1 = findPort(port);
+	Port *p2 = ((StdScheduleNode *)dest)->findPort(destport);
+
+	if(p1 && p2)
+	{
+		if((p1->flags() & streamIn) && (p2->flags() & streamOut))
+		{
+			p1->vport()->connect(p2->vport());
+		}
+		else if((p2->flags() & streamIn) && (p1->flags() & streamOut))
+		{
+			p2->vport()->connect(p1->vport());
+		}
+	}
+}
+
+void StdScheduleNode::disconnect(const string& port, ScheduleNode *dest,
+		                                             const string& destport)
+{
+	RemoteScheduleNode *rsn = dest->remoteScheduleNode();
+	if(rsn)
+	{
+		// RemoteScheduleNodes know better how to disconnect remotely
+		rsn->disconnect(destport,this,port);
+		return;
+	}
+
+	flowSystem->restart();
+
+	Port *p1 = findPort(port);
+	Port *p2 = ((StdScheduleNode *)dest)->findPort(destport);
+
+	if(p1 && p2)
+	{
+		if((p1->flags() & streamIn) && (p2->flags() & streamOut))
+		{
+			p1->vport()->disconnect(p2->vport());
+		}
+		else if((p2->flags() & streamIn) && (p1->flags() & streamOut))
+		{
+			p2->vport()->disconnect(p1->vport());
+		}
+	}
+}
+
+AttributeType StdScheduleNode::queryFlags(const std::string& port)
+{
+	arts_debug("findPort(%s)", port.c_str());
+	arts_debug("have %ld ports", ports.size());
+	Port *p1 = findPort(port);
+	arts_debug("done");
+
+	if(p1)
+	{
+		arts_debug("result %d",(long)p1->flags());
+		return p1->flags();
+	}
+	arts_debug("failed");
+	return (AttributeType)0;
+}
+
+void StdScheduleNode::setFloatValue(const string& port, float value)
+{
+	AudioPort *p = findPort(port)->audioPort();
+
+	if(p) {
+		p->vport()->setFloatValue(value);
+	} else {
+		assert(false);
+	}
+}
+
+unsigned long StdScheduleNode::inputConnectionCount(const string& port)
+{
+	unsigned long result = 0;
+
+	unsigned int c;
+	for(c = 0; c < inConnCount; c++)
+	{
+		if(inConn[c]->name() == port)
+		{
+			if(inConn[c]->source || inConn[c]->gslIsConstant)
+				result++;
+		}
+	}
+
+	return result;
+}
+
+unsigned long StdScheduleNode::outputConnectionCount(const string& port)
+{
+	unsigned long result = 0;
+
+	unsigned int c;
+	for(c = 0; c < outConnCount; c++)
+	{
+		if(outConn[c]->name() == port)
+			result += outConn[c]->destcount;
+	}
+
+	return result;
+}
+
+StdFlowSystem::StdFlowSystem()
+{
+	_suspended = false;
+	needUpdateStarted = false;
+
+	/* TODO: correct parameters */
+	static bool gsl_is_initialized = false;
+	if(!gsl_is_initialized)
+	{
+		GslConfigValue values[3] = {
+			{ "wave_chunk_padding", 8 },
+			{ "dcache_block_size",  4000, },
+			{ 0, 0 }
+		};
+		gsl_is_initialized = true;
+
+		if (!g_thread_supported ())
+			g_thread_init(0);
+		gsl_init(values, (GslMutexTable *)gslGlobalMutexTable);
+
+		/*
+		 * FIXME: both of these are really supposed to be tunable
+		 * - the 512 because of low-latency apps, where calculating smaller
+		 *   block sizes might be necessary
+		 * - the 44100 because of the obvious reason, that not every artsd
+		 *   is running at that rate
+		 */
+		gsl_engine_init(false, 512, 44100, /* subsamplemask */ 63);
+		if(gslGlobalMutexTable)
+			arts_debug("gsl: using Unix98 pthreads directly for mutexes and conditions");
+		/*gsl_engine_debug_enable(GslEngineDebugLevel(GSL_ENGINE_DEBUG_JOBS | GSL_ENGINE_DEBUG_SCHED));*/
+	}
+	gslMainLoop.initialize();
+}
+
+ScheduleNode *StdFlowSystem::addObject(Object_skel *object)
+{
+	// do not add new modules when being in suspended state
+	restart();
+
+	StdScheduleNode *node = new StdScheduleNode(object,this);
+	nodes.push_back(node);
+	return node;
+}
+
+void StdFlowSystem::removeObject(ScheduleNode *node)
+{
+	StdScheduleNode *xnode = (StdScheduleNode *)node->cast("StdScheduleNode");
+	assert(xnode);
+	nodes.remove(xnode);
+	delete xnode;
+}
+
+bool StdFlowSystem::suspended()
+{
+	return _suspended;
+}
+
+bool StdFlowSystem::suspendable()
+{
+	/*
+	 * What it does:
+	 * -------------
+	 *
+	 * The suspension algorithm will first divide the graph of modules into
+	 * subgraphs of interconnected modules. A subgraph is suspendable if
+	 * all of its modules are suspendable and the subgraph does not contain
+	 * producer(s) and consumer(s) at the same time.
+	 *
+	 * Finally, our module graph is suspendable if all its subgraphs are.
+	 *
+	 * How it is implemented:
+	 * ----------------------
+	 *
+	 * For efficiency reasons, both steps are merged together. First all
+	 * modules will be marked as unseen. Then a module is picked and
+	 * all modules that it connects to are recursively added to the
+	 * subgraph.
+	 */
+
+	/*
+	 * initialization: no nodes are seen
+	 */
+	std::list<StdScheduleNode *>::iterator i;
+	for (i = nodes.begin(); i != nodes.end(); i++)
+	{
+		StdScheduleNode *node = *i;
+		node->suspendTag = false;
+	}
+
+	stack<StdScheduleNode*> todo;
+	for(i = nodes.begin(); i != nodes.end(); i++)
+	{
+		bool haveConsumer = false;
+		bool haveProducer = false;
+
+		/*
+		 * examine the subgraph consisting of all nodes connected to (*i)
+		 * (only will do anything if suspendTag is not already set)
+		 */
+
+		todo.push(*i);
+		do
+		{
+			StdScheduleNode *node = todo.top();
+			todo.pop();
+
+			if(!node->suspendTag)
+			{
+				node->suspendTag = true;	// never examine this node again
+
+				switch (node->suspendable())
+				{
+					case asNoSuspend|asProducer:
+					case asNoSuspend|asConsumer:
+					case asNoSuspend:
+							return false;
+						break;
+					case asSuspend:
+					case asSuspendStop:	
+							/* nothing */
+						break;
+					case asSuspend|asProducer:
+					case asSuspendStop|asProducer:
+							if(haveConsumer)
+								return false;
+							else
+								haveProducer = true;
+						break;
+					case asSuspend|asConsumer:
+					case asSuspendStop|asConsumer:
+							if(haveProducer)
+								return false;
+							else
+								haveConsumer = true;
+						break;
+					default:
+						arts_fatal("bad suspend value %d", node->suspendable());
+				}
+
+				unsigned int c;
+				for(c = 0; c < node->inConnCount; c++)
+				{
+					if(node->inConn[c]->source)
+						todo.push(node->inConn[c]->source->parent);
+				}
+	
+				for(c = 0; c < node->outConnCount; c++)
+				{
+					std::list<Port *>::iterator ci;
+
+					for(ci = node->outConn[c]->autoDisconnect.begin();
+						ci != node->outConn[c]->autoDisconnect.end(); ci++)
+					{
+						AudioPort *dest = (*ci)->audioPort();
+						if(dest)
+							todo.push(dest->parent);
+					}
+				}
+			}
+		} while(!todo.empty());
+	}
+	return true;
+}
+
+void StdFlowSystem::suspend()
+{
+	if(!_suspended)
+	{
+		std::list<StdScheduleNode *>::iterator i;
+		for(i = nodes.begin();i != nodes.end();i++)
+		{
+			StdScheduleNode *node = *i;
+			node->suspend();
+		}
+		_suspended = true;
+	}
+}
+
+void StdFlowSystem::restart()
+{
+	if(_suspended)
+	{
+		std::list<StdScheduleNode *>::iterator i;
+		for(i = nodes.begin();i != nodes.end();i++)
+		{
+			StdScheduleNode *node = *i;
+			node->restart();
+		}
+		_suspended = false;
+	}
+}
+
+/* remote accessibility */
+
+void StdFlowSystem::startObject(Object node)
+{
+	StdScheduleNode *sn =
+		(StdScheduleNode *)node._node()->cast("StdScheduleNode");
+	sn->start();
+}
+
+void StdFlowSystem::stopObject(Object node)
+{
+	StdScheduleNode *sn =
+		(StdScheduleNode *)node._node()->cast("StdScheduleNode");
+	sn->stop();
+}
+
+void StdFlowSystem::connectObject(Object sourceObject,const string& sourcePort,
+					Object destObject, const std::string& destPort)
+{
+	arts_debug("connect port %s to %s", sourcePort.c_str(), destPort.c_str());
+	StdScheduleNode *sn =
+		(StdScheduleNode *)sourceObject._node()->cast("StdScheduleNode");
+	assert(sn);
+
+	Port *port = sn->findPort(sourcePort);
+	assert(port);
+
+	StdScheduleNode *destsn =
+		(StdScheduleNode *)destObject._node()->cast("StdScheduleNode");
+	if(destsn)
+	{
+		sn->connect(sourcePort,destsn,destPort);
+		return;
+	}
+
+	ASyncPort *ap = port->asyncPort();
+
+	if(ap)
+	{
+		FlowSystemSender sender;
+		FlowSystemReceiver receiver;
+		FlowSystem remoteFs;
+
+		string dest = destObject.toString() + ":" + destPort;
+		ASyncNetSend *netsend = new ASyncNetSend(ap, dest);
+
+		sender = FlowSystemSender::_from_base(netsend); // don't release netsend
+		remoteFs = destObject._flowSystem();
+		receiver = remoteFs.createReceiver(destObject, destPort, sender);
+		netsend->setReceiver(receiver);
+		arts_debug("connected an asyncnetsend");
+	}
+}
+
+void StdFlowSystem::disconnectObject(Object sourceObject,
+  	const string& sourcePort, Object destObject, const std::string& destPort)
+{
+	arts_debug("disconnect port %s and %s",sourcePort.c_str(),destPort.c_str());
+	StdScheduleNode *sn =
+		(StdScheduleNode *)sourceObject._node()->cast("StdScheduleNode");
+	assert(sn);
+
+	Port *port = sn->findPort(sourcePort);
+	assert(port);
+
+	StdScheduleNode *destsn =
+		(StdScheduleNode *)destObject._node()->cast("StdScheduleNode");
+	if(destsn)
+	{
+		sn->disconnect(sourcePort,destsn,destPort);
+		return;
+	}
+
+	ASyncPort *ap = port->asyncPort();
+	if(ap)
+	{
+		string dest = destObject.toString() + ":" + destPort;
+		ap->disconnectRemote(dest);
+		arts_debug("disconnected an asyncnetsend");
+	}
+}
+
+AttributeType StdFlowSystem::queryFlags(Object node, const std::string& port)
+{
+	StdScheduleNode *sn =
+		(StdScheduleNode *)node._node()->cast("StdScheduleNode");
+	assert(sn);
+	return sn->queryFlags(port);
+}
+
+void StdFlowSystem::setFloatValue(Object node, const std::string& port,
+							float value)
+{
+	StdScheduleNode *sn =
+		(StdScheduleNode *)node._node()->cast("StdScheduleNode");
+	assert(sn);
+	sn->setFloatValue(port,value);
+}
+
+FlowSystemReceiver StdFlowSystem::createReceiver(Object object,
+							const string &port, FlowSystemSender sender)
+{
+	StdScheduleNode *sn =
+		(StdScheduleNode *)object._node()->cast("StdScheduleNode");
+
+	Port *p = sn->findPort(port);
+	assert(p);
+
+	ASyncPort *ap = p->asyncPort();
+
+	if(ap)
+	{
+		arts_debug("creating packet receiver");
+		return FlowSystemReceiver::_from_base(new ASyncNetReceive(ap, sender));
+	}
+	return FlowSystemReceiver::null();
+}
+
+void StdFlowSystem::updateStarted()
+{
+	if(!needUpdateStarted)
+		return;
+
+	needUpdateStarted = false;
+
+	std::list<StdScheduleNode*>::iterator ni;
+	GslTrans *trans = 0;
+
+	for(ni = nodes.begin(); ni != nodes.end(); ni++)
+	{
+		StdScheduleNode *node = *ni;
+
+		if(node->running != node->gslRunning)
+		{
+			if(!trans)
+				trans = gsl_trans_open();
+			gsl_trans_add(trans, gsl_job_set_consumer(node->gslModule, node->running));
+			node->gslRunning = node->running;
+		}
+	}
+	if(trans)
+		gsl_trans_commit(trans);
+}
+
+void StdFlowSystem::startedChanged()
+{
+	needUpdateStarted = true;
+}
+
+// hacked initialization of Dispatcher::the()->flowSystem ;)
+
+namespace Arts {
+
+static class SetFlowSystem : public StartupClass {
+	FlowSystem_impl *fs;
+public:
+	void startup()
+	{
+		fs = new StdFlowSystem;
+		Dispatcher::the()->setFlowSystem(fs);
+	}
+	void shutdown()
+	{
+		fs->_release();
+	}
+} sfs;
+
+}
+
diff --git a/flow/gslschedule.h b/flow/gslschedule.h
new file mode 100644
index 0000000..4564dfc
--- /dev/null
+++ b/flow/gslschedule.h
@@ -0,0 +1,262 @@
+   /*
+
+    Copyright (C) 2000-2002 Stefan Westerfeld
+                            stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef ARTS_GSLSCHEDULE_H
+#define ARTS_GSLSCHEDULE_H
+
+#include "artsflow.h"
+#include "flowsystem.h"
+#include <gsl/gsldefs.h>
+#include <string>
+#include <list>
+
+/*
+ * BC - Status (2002-03-08): Port, AudioPort, MultiPort, StdFlowSystem,
+ *                           StdScheduleNode
+ *
+ * None of these classes is considered part of the public API. Do NOT use it
+ * in your apps. These are part of the implementation of libartsflow's
+ * StdFlowSystem, and subject to change with the needs of it.
+ *
+ * If you want to access flowsystem functionality, do so over the core.idl
+ * specified flowsystem interface, (object)->_node() or stuff in mcop/connect.h.
+ */
+
+namespace Arts {
+
+class StdScheduleNode;
+
+class Port {
+	friend class VPort;				// TODO: debugging, remove me when it works?
+	friend class VPortConnection;	// TODO: debugging, remove me when it works?
+protected:
+	std::string _name;
+public:
+	void *_ptr;
+public:				// FIXME: GSL
+	AttributeType _flags;
+	StdScheduleNode *parent;
+
+	// each port has a virtual port, which allows port redirection
+	class VPort *_vport;
+
+	// dynamic ports are created to implement multiports
+	bool _dynamicPort;
+
+	// functionality to remove all connections automatically as soon as
+	// the module gets destroyed
+	std::list<Port *> autoDisconnect;
+
+	/**
+	 * call these from your (dis)connect implementation as soon as a the
+	 * port gets (dis)connected to some other port (only one call per
+	 * connection: destinationport->addAutoDisconnect(sourceport), not
+	 * for the other direction)
+	 */
+	void addAutoDisconnect(Port *source);
+	void removeAutoDisconnect(Port *source);
+
+public:
+	Port(const std::string& name, void *ptr, long flags,
+			                      StdScheduleNode* parent);
+	virtual ~Port();
+
+	inline VPort* vport()		 { assert(_vport); return _vport; }
+	AttributeType flags();
+	std::string name();
+	void setPtr(void *ptr);
+
+	inline bool dynamicPort()    { return _dynamicPort; }
+	inline void setDynamicPort() { _dynamicPort = true; }
+
+	virtual class AudioPort *audioPort();
+	virtual class ASyncPort *asyncPort();
+
+	virtual void disconnectAll();
+	virtual void connect(Port *) = 0;
+	virtual void disconnect(Port *) = 0;
+};
+
+class AudioPort : public Port {
+public:		// FIXME: GSL
+	AudioPort *source;
+
+public:
+	StdScheduleNode *sourcemodule;
+	unsigned long destcount;
+	unsigned long gslEngineChannel;
+
+	/* GSL */
+	bool gslIsConstant;
+	float gslConstantValue;
+
+	AudioPort(const std::string& name,
+			  void *ptr, long flags,StdScheduleNode *parent);
+	~AudioPort();
+
+	virtual class AudioPort *audioPort();
+
+	void setFloatValue(float f);
+	void connect(Port *psource);
+	void disconnect(Port *psource);
+};
+
+class MultiPort : public Port {
+protected:
+	struct Part {
+		AudioPort *src, *dest;
+	};
+
+	std::list<Part> parts;
+	typedef float *float_ptr;
+	float **conns;
+	long nextID;
+	void initConns();
+
+public:
+	MultiPort(const std::string& name,
+			  void *ptr, long flags,StdScheduleNode *parent);
+	~MultiPort();
+
+	void connect(Port *port);
+	void disconnect(Port *port);
+};
+
+class StdFlowSystem;
+
+class StdScheduleNode :public ScheduleNode
+{
+	friend class StdFlowSystem;
+	bool running;
+	bool suspended;
+
+	Object_skel *_object;
+	SynthModule_base *module;
+	StdFlowSystem *flowSystem;
+	std::list<Port *> ports;
+	AudioPort **inConn;
+	AudioPort **outConn;
+	unsigned long inConnCount, outConnCount;
+	typedef AudioPort *AudioPort_ptr;
+	QueryInitStreamFunc queryInitStreamFunc;
+
+	void freeConn();
+	void rebuildConn();
+	void accessModule();
+
+	static void gslProcess(GslModule *module, guint n_values);
+	public: /* TODO? */
+	Port *findPort(const std::string& name);
+
+public:
+
+	GslModule *gslModule;
+	bool gslRunning;
+
+	/**
+	 * this is used by StdFlowSystem::suspend() to mark nodes which
+	 * have already been seen by the algorithm
+	 */
+	bool suspendTag;
+
+	StdScheduleNode(Object_skel *object, StdFlowSystem *flowSystem);
+	virtual ~StdScheduleNode();
+	void initStream(const std::string& name, void *ptr, long flags);
+	void addDynamicPort(Port *port);
+	void removeDynamicPort(Port *port);
+
+	void start();
+	void stop();
+	void requireFlow();
+	void virtualize(const std::string& port, ScheduleNode *implNode,
+											 const std::string& implPort);
+	void devirtualize(const std::string& port, ScheduleNode *implNode,
+											   const std::string& implPort);
+
+	// AutoSuspend stuff
+	AutoSuspendState suspendable();
+	void suspend();
+	void restart();
+
+	void connect(const std::string& port, ScheduleNode *dest,
+			                              const std::string& destport);
+	void disconnect(const std::string& port, ScheduleNode *dest,
+			                                 const std::string& destport);
+
+	AttributeType queryFlags(const std::string& port);
+	void setFloatValue(const std::string& port, float value);
+
+	Object_skel *object();
+	void *cast(const std::string &target);
+
+	// used by StdSynthModule
+	unsigned long inputConnectionCount(const std::string& port);
+	unsigned long outputConnectionCount(const std::string& port);
+
+	bool _connectionCountChanged;
+	inline bool connectionCountChanged() {
+		bool c = _connectionCountChanged;
+		_connectionCountChanged = false;
+		return c;
+	}
+};
+
+class StdFlowSystem :public FlowSystem_impl
+{
+protected:
+	std::list<StdScheduleNode *> nodes;
+	bool _suspended;
+	bool needUpdateStarted;
+public:
+	StdFlowSystem();
+
+	ScheduleNode *addObject(Object_skel *object);
+	void removeObject(ScheduleNode *node);
+
+	/* AutoSuspend */
+	bool suspendable();
+	bool suspended();
+	void suspend();
+	void restart();
+
+	/* remote accessibility */
+	void startObject(Object node);
+	void stopObject(Object node);
+	void connectObject(Object sourceObject, const std::string& sourcePort,
+						Object destObject, const std::string& destPort);
+	void disconnectObject(Object sourceObject, const std::string& sourcePort,
+						Object destObject, const std::string& destPort);
+	AttributeType queryFlags(Object node, const std::string& port);
+	void setFloatValue(Object node, const std::string& port, float value);
+
+	FlowSystemReceiver createReceiver(Object object, const std::string &port,
+										FlowSystemSender sender);
+
+	/* interface to StdScheduleNode */
+	void schedule(unsigned long samples);
+	void updateStarted();
+	void startedChanged();
+};
+
+}
+
+#endif
diff --git a/flow/mcopclass/DataHandlePlay.mcopclass b/flow/mcopclass/DataHandlePlay.mcopclass
new file mode 100644
index 0000000..cd84c48
--- /dev/null
+++ b/flow/mcopclass/DataHandlePlay.mcopclass
@@ -0,0 +1,2 @@
+Interface=Arts::DataHandlePlay,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Makefile.am b/flow/mcopclass/Makefile.am
new file mode 100644
index 0000000..faf2683
--- /dev/null
+++ b/flow/mcopclass/Makefile.am
@@ -0,0 +1,15 @@
+mcopclassdir = $(libdir)/mcop/Arts
+mcopclass_DATA = Synth_ADD.mcopclass \
+  Synth_FREQUENCY.mcopclass \
+  Synth_MUL.mcopclass \
+  Synth_MULTI_ADD.mcopclass \
+  Synth_PLAY.mcopclass \
+  Synth_RECORD.mcopclass \
+  Synth_PLAY_WAV.mcopclass \
+  Synth_WAVE_SIN.mcopclass \
+  Synth_BUS_DOWNLINK.mcopclass \
+  Synth_BUS_UPLINK.mcopclass \
+  Synth_AMAN_PLAY.mcopclass \
+  Synth_AMAN_RECORD.mcopclass \
+  DataHandlePlay.mcopclass \
+  WaveDataHandle.mcopclass
diff --git a/flow/mcopclass/Synth_ADD.mcopclass b/flow/mcopclass/Synth_ADD.mcopclass
new file mode 100644
index 0000000..0429b3f
--- /dev/null
+++ b/flow/mcopclass/Synth_ADD.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_ADD,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_AMAN_PLAY.mcopclass b/flow/mcopclass/Synth_AMAN_PLAY.mcopclass
new file mode 100644
index 0000000..02f8e99
--- /dev/null
+++ b/flow/mcopclass/Synth_AMAN_PLAY.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_AMAN_PLAY,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_AMAN_RECORD.mcopclass b/flow/mcopclass/Synth_AMAN_RECORD.mcopclass
new file mode 100644
index 0000000..c92cb76
--- /dev/null
+++ b/flow/mcopclass/Synth_AMAN_RECORD.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_AMAN_RECORD,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_BUS_DOWNLINK.mcopclass b/flow/mcopclass/Synth_BUS_DOWNLINK.mcopclass
new file mode 100644
index 0000000..bcc0c2a
--- /dev/null
+++ b/flow/mcopclass/Synth_BUS_DOWNLINK.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_BUS_DOWNLINK,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_BUS_UPLINK.mcopclass b/flow/mcopclass/Synth_BUS_UPLINK.mcopclass
new file mode 100644
index 0000000..d262b1e
--- /dev/null
+++ b/flow/mcopclass/Synth_BUS_UPLINK.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_BUS_UPLINK,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_FREQUENCY.mcopclass b/flow/mcopclass/Synth_FREQUENCY.mcopclass
new file mode 100644
index 0000000..91c5016
--- /dev/null
+++ b/flow/mcopclass/Synth_FREQUENCY.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_FREQUENCY,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_MUL.mcopclass b/flow/mcopclass/Synth_MUL.mcopclass
new file mode 100644
index 0000000..c1087c2
--- /dev/null
+++ b/flow/mcopclass/Synth_MUL.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_MUL,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_MULTI_ADD.mcopclass b/flow/mcopclass/Synth_MULTI_ADD.mcopclass
new file mode 100644
index 0000000..f883f9e
--- /dev/null
+++ b/flow/mcopclass/Synth_MULTI_ADD.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_MULTI_ADD,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_PLAY.mcopclass b/flow/mcopclass/Synth_PLAY.mcopclass
new file mode 100644
index 0000000..35c3ac4
--- /dev/null
+++ b/flow/mcopclass/Synth_PLAY.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_PLAY,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_PLAY_WAV.mcopclass b/flow/mcopclass/Synth_PLAY_WAV.mcopclass
new file mode 100644
index 0000000..8ca8d5c
--- /dev/null
+++ b/flow/mcopclass/Synth_PLAY_WAV.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_PLAY_WAV,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_RECORD.mcopclass b/flow/mcopclass/Synth_RECORD.mcopclass
new file mode 100644
index 0000000..8b69cf7
--- /dev/null
+++ b/flow/mcopclass/Synth_RECORD.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_RECORD,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/Synth_WAVE_SIN.mcopclass b/flow/mcopclass/Synth_WAVE_SIN.mcopclass
new file mode 100644
index 0000000..422d68f
--- /dev/null
+++ b/flow/mcopclass/Synth_WAVE_SIN.mcopclass
@@ -0,0 +1,3 @@
+Buildable=true
+Interface=Arts::Synth_WAVE_SIN,Arts::SynthModule,Arts::Object
+Language=C++
diff --git a/flow/mcopclass/WaveDataHandle.mcopclass b/flow/mcopclass/WaveDataHandle.mcopclass
new file mode 100644
index 0000000..d25effd
--- /dev/null
+++ b/flow/mcopclass/WaveDataHandle.mcopclass
@@ -0,0 +1,2 @@
+Interface=Arts::WaveDataHandle,Arts::Object
+Language=C++
diff --git a/flow/pipebuffer.cc b/flow/pipebuffer.cc
new file mode 100644
index 0000000..bb6073a
--- /dev/null
+++ b/flow/pipebuffer.cc
@@ -0,0 +1,166 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "pipebuffer.h"
+#include <assert.h>
+#include <cstring>
+
+using namespace std;
+using namespace Arts;
+
+PipeSegment::PipeSegment(long size, void *buffer)
+{
+	this->buffer = new char[size];
+	this->currentpos = this->buffer;
+	memcpy(this->buffer,buffer,size);
+
+	_remaining = size;
+}
+
+PipeSegment::~PipeSegment()
+{
+	delete[] buffer;
+}
+
+void *PipeSegment::data()
+{
+	return currentpos;
+}
+
+long PipeSegment::remaining()
+{
+	return _remaining;
+}
+
+void PipeSegment::skip(long count)
+{
+	_remaining -= count;
+	currentpos += count;
+	assert(_remaining >= 0);
+}
+
+PipeBuffer::PipeBuffer()
+{
+	_size = 0;
+}
+
+PipeBuffer::~PipeBuffer()
+{
+	clear();
+}
+
+void PipeBuffer::clear()
+{
+	while(segments.size() != 0)
+	{
+		PipeSegment *first = *segments.begin();
+		delete first;
+
+		segments.pop_front();
+	}
+	_size = 0;
+}
+
+void *PipeBuffer::peek(long size)
+{
+	while(!segments.empty())
+	{
+		PipeSegment *first = *segments.begin();
+		if(size <= first->remaining())
+			return first->data();
+	}
+	return 0;
+}
+
+void PipeBuffer::skip(long size)
+{
+	while(!segments.empty() && size > 0)
+	{
+		PipeSegment *first = *segments.begin();
+
+		// if we have less data to skip than the first segment contains
+		if(size < first->remaining())
+		{
+			// skip the data inside the segment
+
+			_size -= size;
+			first->skip(size);
+			return;
+		}
+		else
+		{
+			// otherwise erase the first segment
+
+			_size -= first->remaining();
+			size -= first->remaining();
+
+			delete first;
+			segments.pop_front();
+		}
+	}
+}
+
+long PipeBuffer::read(long size, void *buffer)
+{
+	long readbytes = 0;
+	char *bptr = (char *)buffer;
+
+	while(!segments.empty() && size > 0)
+	{
+		PipeSegment *first = *segments.begin();
+		long readCnt = size;
+		if(readCnt > first->remaining()) readCnt = first->remaining();
+
+		memcpy(bptr,first->data(),readCnt);
+
+		first->skip(readCnt);
+		size -= readCnt;
+		bptr += readCnt;
+		readbytes += readCnt;
+
+		if(first->remaining() == 0)
+		{
+			delete first;
+			segments.pop_front();
+		}
+	}
+
+	_size -= readbytes;
+	return readbytes;
+}
+
+long PipeBuffer::size()
+{
+	return _size;
+}
+
+void PipeBuffer::write(long size, void *buffer)
+{
+	segments.push_back(new PipeSegment(size,buffer));
+	_size += size;
+}
+
+void PipeBuffer::unRead(long size, void *buffer)
+{
+	segments.push_front(new PipeSegment(size,buffer));
+	_size += size;
+}
diff --git a/flow/pipebuffer.h b/flow/pipebuffer.h
new file mode 100644
index 0000000..c44e16b
--- /dev/null
+++ b/flow/pipebuffer.h
@@ -0,0 +1,75 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef __PIPEBUFFER_H__
+#define __PIPEBUFFER_H__
+
+/*
+ * BC - Status (2002-03-08): PipeSegment, PipeBuffer
+ *
+ * None of these classes is considered part of the public API. Do NOT use it
+ * in your apps. These are part of the implementation of libartsflow's
+ * AudioSubSystem, and subject to change/disappearing due to optimization
+ * work.
+ */
+
+
+#include <list>
+namespace Arts {
+
+class PipeSegment {
+	long _remaining;
+	char *currentpos, *buffer;
+public:
+	PipeSegment(long size, void *buffer);
+	~PipeSegment();
+
+	void *data();
+	long remaining();
+	void skip(long count);
+};
+
+class PipeBuffer {
+protected:
+	std::list<PipeSegment *> segments;
+	long _size;
+
+public:
+	PipeBuffer();
+	~PipeBuffer();
+
+	// reading
+	void *peek(long size);
+	void skip(long size);
+	long read(long size, void *buffer);
+	void unRead(long size, void *buffer);
+
+	// writing
+	void write(long size, void *buffer);
+	void clear();
+
+	// status
+	long size();
+};
+}
+
+#endif
diff --git a/flow/resample.cc b/flow/resample.cc
new file mode 100644
index 0000000..45cd099
--- /dev/null
+++ b/flow/resample.cc
@@ -0,0 +1,305 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "resample.h"
+#include "debug.h"
+#include <math.h>
+#include <assert.h>
+#include <stdio.h>
+
+#define compose_16le(first,second) \
+    (((((second)+128)&0xff) << 8)+(first))
+ 
+#define compose_16be(first,second) \
+    (((((first)+128)&0xff) << 8)+(second))
+
+#define conv_16_float(x) \
+    ((float)((x)-32768)/32768.0)                                                
+
+#define conv_8_float(x) \
+	((float)((x)-128)/128.0)
+
+using namespace Arts;
+
+class Arts::ResamplerPrivate {
+public:
+	bool underrun;	
+	Resampler::Endianness endianness;
+};
+
+const unsigned int Resampler::bufferSize;
+const unsigned int Resampler::bufferWrap;
+
+Resampler::Resampler(Refiller *refiller) :
+	dropBytes(0), refiller(refiller), pos(0.0), step(1.0), channels(2),
+	bits(16),
+	block(0), haveBlock(-1)
+{
+	d = new ResamplerPrivate();
+	d->underrun = false;
+	d->endianness = littleEndian;
+	updateSampleSize();
+}
+
+Resampler::~Resampler()
+{
+	delete d;
+}
+
+void Resampler::updateSampleSize()
+{
+	sampleSize = channels * bits / 8;
+	bufferSamples = bufferSize / sampleSize;
+}
+
+void Resampler::setStep(double newStep)
+{
+	arts_return_if_fail(newStep > 0);
+
+	step = newStep;
+}
+
+void Resampler::setChannels(int newChannels)
+{
+	arts_return_if_fail(newChannels == 1 || newChannels == 2);
+
+	channels = newChannels;
+	updateSampleSize();
+}
+
+void Resampler::setBits(int newBits)
+{
+	arts_return_if_fail(newBits == 8 || newBits == 16);
+
+	bits = newBits;
+	updateSampleSize();
+}
+
+void Resampler::setEndianness(Endianness newEndianness)
+{
+	arts_return_if_fail(newEndianness == bigEndian || newEndianness == littleEndian);
+
+	d->endianness = newEndianness;
+}
+
+bool Resampler::underrun()
+{
+	return d->underrun;
+}
+
+void Resampler::ensureRefill()
+{
+	if(haveBlock == block) return;
+
+	unsigned long missing;
+	if(block == 0)
+	{
+		missing = bufferSize+sampleSize
+				- refiller->read(buffer,bufferSize+sampleSize);
+
+		d->underrun = (missing == bufferSize+sampleSize);
+	}
+	else
+	{
+		/*
+		 * try to drop away "half-sample" reads from the last refill
+		 */
+		if(dropBytes > 0)
+			dropBytes -= refiller->read(buffer,dropBytes);
+
+		/*
+		 * only if this worked there is hope that we can read sane data
+		 */
+		if(dropBytes == 0)
+		{
+			missing = bufferSize
+					- refiller->read(&buffer[sampleSize], bufferSize);
+
+			d->underrun = (missing == bufferSize);
+		}
+		else
+		{
+			missing = bufferSize;
+			d->underrun = true;
+		}
+	}
+	haveBlock++;
+	assert(haveBlock == block);
+
+	/*
+	 * If we don't have enough input to fill the block fully, it might be
+	 * that the input stall occurred in the middle of a sample. For instance,
+	 * if samples are 4 bytes long, it might be that we would have needed
+	 * 13 more bytes to do a full refill.
+	 *
+	 * In this situation, there are four samples and one byte missing to
+	 * refill the buffer - the one byte is what we need to care about here:
+	 * on the next read, we'll have one byte too much (if we simply ignore
+	 * the fact, we end up with misaligned reading, causing noise, or
+	 * swapped stereo channels or similar).
+	 *
+	 * So we set dropBytes here, which is a variable which indicates how
+	 * many bytes to drop away upon next refill.
+	 */
+	if(missing & (sampleSize - 1))
+		dropBytes = missing & (sampleSize - 1);
+
+	unsigned int i = 0, wrap = (block == 0)?0:sampleSize;
+	if(bits == 16)
+	{
+		// wrap the last part of the buffer back to the beginning (history)
+		while(i<wrap)
+		{
+			fbuffer[i/2] = fbuffer[(bufferSize+i)/2];
+			i += 2;
+		}
+
+		// convert data from incoming
+		if(d->endianness == littleEndian)
+		{
+			while(i<bufferSize+sampleSize-missing)
+			{
+				fbuffer[i/2] = conv_16_float(compose_16le(buffer[i],buffer[i+1]));
+				i += 2;
+			}
+		}
+		else
+		{
+			while(i<bufferSize+sampleSize-missing)
+			{
+				fbuffer[i/2] = conv_16_float(compose_16be(buffer[i],buffer[i+1]));
+				i += 2;
+			}
+		}
+
+		// fill up missing bytes with zero samples
+		while(i<bufferSize+sampleSize)
+		{
+			fbuffer[i/2] = 0.0;
+			i += 2;
+		}
+	}
+	else if(bits == 8)
+	{
+		// wrap the last part of the buffer back to the beginning (history)
+		while(i<wrap)
+		{
+			fbuffer[i] = fbuffer[bufferSize+i];
+			i++;
+		}
+
+		// convert data from incoming
+		while(i<bufferSize+sampleSize-missing)
+		{
+			fbuffer[i] = conv_8_float(buffer[i]);
+			i++;
+		}
+
+		// fill up missing bytes with zero samples
+		while(i<bufferSize+sampleSize)
+		{
+			fbuffer[i++] = 0.0;
+		}
+	}
+	else
+	{
+		assert(false);
+	}
+}
+
+#define RESAMPLER_STEP()							\
+	pos += step;									\
+	i++;											\
+	while(pos >= bufferSamples)						\
+	{												\
+		pos -= bufferSamples;						\
+		block++;									\
+		ensureRefill();								\
+	}
+
+void Resampler::run(float *left, float *right, unsigned long samples)
+{
+	ensureRefill();
+	unsigned long i = 0;
+	double delta = step - floor(step);
+	bool interpolate = fabs(delta) > 0.001;
+
+	if(channels == 2 && interpolate)
+	{
+		while(i < samples)
+		{
+			double error = pos - floor(pos);
+			unsigned long offset = 2*(unsigned long)pos;
+
+			left[i]  = fbuffer[offset+0]*(1.0-error)+fbuffer[offset+2]*error;
+			right[i] = fbuffer[offset+1]*(1.0-error)+fbuffer[offset+3]*error;
+			RESAMPLER_STEP();
+		}
+	}
+	else if(channels == 1 && interpolate)
+	{
+		while(i < samples)
+		{
+			double error = pos - floor(pos);
+			unsigned long offset = (unsigned long)pos;
+
+			left[i] = right[i] = fbuffer[offset]*(1.0-error)
+							   + fbuffer[offset+1]*error;
+			RESAMPLER_STEP();
+		}
+	}
+	else if(channels == 2)
+	{
+		while(i < samples)
+		{
+			unsigned long offset = 2*(unsigned long)pos;
+
+			left[i]  = fbuffer[offset+0];
+			right[i] = fbuffer[offset+1];
+			RESAMPLER_STEP();
+		}
+	}
+	else if(channels == 1)
+	{
+		while(i < samples)
+		{
+			unsigned long offset = (unsigned long)pos;
+
+			left[i] = right[i] = fbuffer[offset];
+			RESAMPLER_STEP();
+		}
+	}
+	else
+	{
+		assert(false);
+	}
+}
+
+Refiller::~Refiller()
+{
+}
+
+#undef RESAMPLER_STEP
+#undef compose_16le
+#undef compose_16be
+#undef conv_16_float
+#undef conv_8_float
diff --git a/flow/resample.h b/flow/resample.h
new file mode 100644
index 0000000..3cb99e3
--- /dev/null
+++ b/flow/resample.h
@@ -0,0 +1,167 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+
+#ifndef ARTS_FLOW_RESAMPLE_H
+#define ARTS_FLOW_RESAMPLE_H
+
+#include "arts_export.h"
+
+/*
+ * BC - Status (2002-03-08): Resampler / Refiller.
+ *
+ * These classes will be kept binary compatible. Resampler has a private
+ * data pointer for this purpose.
+ */
+
+namespace Arts {
+
+/**
+ * Refiller interface
+ *
+ * this is used by the resampler class
+ */
+class ARTS_EXPORT Refiller {
+public:
+	/**
+	 * callback method to supply data to the Resampler
+	 *
+	 * here you supply data in the encoding specified in the Resampler class
+	 * (bits, channels, endianness) to the Resampler
+	 *
+	 * @param buffer a pointer to a buffer where the data can be filled to
+	 * @param len the size of the buffer in bytes
+	 *
+	 * @returns the number of bytes really available
+	 */
+	virtual unsigned long read(unsigned char *buffer, unsigned long len) = 0;
+	virtual ~Refiller();
+};
+
+class ResamplerPrivate;
+
+/**
+ * The Resampler class resamples data from an input stream, which is read
+ * through the Refiller interface, and renders it into the float format which
+ * aRts usually uses, converting the sampling rate and format as needed.
+ */
+class ARTS_EXPORT Resampler {
+protected:
+	static const unsigned int bufferSize = 256;		//  64 samples in buffer
+	static const unsigned int bufferWrap = 64;		// + "wrap around"
+	/*
+	 * BC: bufferWrap just needs channels * (filtersize - 1) * bytes per sample
+	 * bytes wrap around - this used to be 4: 2 channels, linear interpolation,
+	 * 16bit. However, for supporting float resampling and/or better filters,
+	 * we'll make this 64 to be safe.
+	 */
+
+	int bufferSamples;
+	int sampleSize;
+	int dropBytes;
+
+	Refiller *refiller;
+	double pos, step;
+	int channels,bits;
+
+	unsigned char buffer[bufferSize+bufferWrap];
+	float fbuffer[bufferSize+bufferWrap];
+	long block, haveBlock;
+
+	class ResamplerPrivate *d;
+
+	void updateSampleSize();
+	void ensureRefill();
+public:
+	/**
+	 * constructor
+	 *
+	 */
+	Resampler(Refiller *refiller);
+	~Resampler();
+
+	/**
+	 * sets the resampling step in the input stream
+	 *
+	 * for instance, settings step to 2.0, the file would be played twice as
+	 * fast - you can calculate the resampling step from the sampling rate
+	 * the stream you resample was recorded at, and the sampling rate you want
+	 * it to be resampled to, using
+	 *
+	 *   step = originalSamplingRate / desiredSamplingRate
+	 *
+	 * for instance, if a stream recorded at 22050 Hz is to be played at 48000
+	 * Hz, step would be
+	 *
+	 *   step = 22050 / 48000 = 0.46
+	 */
+	void setStep(double step);
+
+	/**
+	 * sets the number of channels in the input stream
+	 *
+	 * the channels are expected to be interleaved, thus if you have two
+	 * channels, you will have one sample for the left stream, one for the
+	 * right, one for the left, ... and so on
+	 *
+	 * currently only either mono (channels = 1) or stereo (channels = 2)
+	 * streams are supported
+	 */
+	void setChannels(int channels);
+
+	/**
+	 * sets the number of bits in the input stream
+	 *
+	 * currently, only 16 bit and 8 bit streams are supported
+	 */
+	void setBits(int bits);
+
+	enum Endianness { bigEndian, littleEndian };
+
+	/**
+	 * sets the endianess of the input stream
+	 *
+	 * supported are bigEndian and littleEndian
+	 */
+	void setEndianness(Endianness endianness);
+
+	/**
+	 * renders a buffer of float samples from the input stream
+	 *
+	 * the data is obtained by querying the refiller for data from the
+	 * input stream and filling them into the float array pointed to by
+	 * left and right - if reading data fails, the underrun flag is set
+	 */
+	void run(float *left, float *right, unsigned long samples);
+
+	/**
+	 * query the underrun flag
+	 *
+	 * underruns occur if run is called, but no data is available from the
+	 * Refiller object
+	 */
+	bool underrun();
+};
+
+}
+
+#endif /* ARTS_FLOW_RESAMPLE_H */
diff --git a/flow/stdsynthmodule.cc b/flow/stdsynthmodule.cc
new file mode 100644
index 0000000..6d1c122
--- /dev/null
+++ b/flow/stdsynthmodule.cc
@@ -0,0 +1,92 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "stdsynthmodule.h"
+#include "gslschedule.h"
+#include "audiosubsys.h"
+#include "flowsystem.h"
+#include "debug.h"
+
+using namespace Arts;
+using namespace std;
+
+StdSynthModule::StdSynthModule()
+{
+	// TODO: maybe this should be handled over some other mechanism
+
+	samplingRate = AudioSubSystem::the()->samplingRate();
+	samplingRateFloat = (float)samplingRate;
+}
+
+void StdSynthModule::streamInit()
+{
+}
+
+void StdSynthModule::streamStart()
+{
+}
+
+void StdSynthModule::streamEnd()
+{
+}
+
+void StdSynthModule::start()
+{
+	_node()->start();
+}
+
+void StdSynthModule::stop()
+{
+	_node()->stop();
+}
+
+AutoSuspendState StdSynthModule::autoSuspend()
+{
+	return asNoSuspend;
+}
+
+unsigned long StdSynthModule::inputConnectionCount(const std::string& port)
+{
+	StdScheduleNode *xnode = (StdScheduleNode *)
+		_node()->cast("StdScheduleNode");
+	arts_return_val_if_fail(xnode, 0);
+
+	return xnode->inputConnectionCount(port);
+}
+
+unsigned long StdSynthModule::outputConnectionCount(const std::string& port)
+{
+	StdScheduleNode *xnode = (StdScheduleNode *)
+		_node()->cast("StdScheduleNode");
+	arts_return_val_if_fail(xnode, 0);
+
+	return xnode->outputConnectionCount(port);
+}
+
+bool StdSynthModule::connectionCountChanged()
+{
+	StdScheduleNode *xnode = (StdScheduleNode *)
+		_node()->cast("StdScheduleNode");
+	arts_return_val_if_fail(xnode, 0);
+
+	return xnode->connectionCountChanged();
+}
diff --git a/flow/stdsynthmodule.h b/flow/stdsynthmodule.h
new file mode 100644
index 0000000..fb1830a
--- /dev/null
+++ b/flow/stdsynthmodule.h
@@ -0,0 +1,65 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef STDSYNTHMODULE_H
+#define STDSYNTHMODULE_H
+
+#include "arts_export.h"
+#include "artsflow.h"
+
+/*
+ * BC - Status (2002-03-08): StdSynthModule
+ *
+ * This class is intended for public use (inheritance) as it supplies a base
+ * for all objects using streams. It will be kept binary compatible.
+ */
+
+namespace Arts {
+
+class StdSynthModulePrivate;
+
+class ARTS_EXPORT StdSynthModule : virtual public SynthModule_base {
+private:
+	StdSynthModulePrivate *d;
+
+protected:
+	long samplingRate;
+	float samplingRateFloat;
+
+public:
+	StdSynthModule();
+
+	void start();
+	void stop();
+
+	void streamInit();
+	void streamStart();
+	void streamEnd();
+
+	AutoSuspendState autoSuspend();
+
+	unsigned long inputConnectionCount(const std::string& portname);
+	unsigned long outputConnectionCount(const std::string& portname);
+	bool connectionCountChanged();
+};
+}
+#endif /* STDSYNTHMODULE_H */
diff --git a/flow/stereoeffectstack_impl.cc b/flow/stereoeffectstack_impl.cc
new file mode 100644
index 0000000..3e82cfb
--- /dev/null
+++ b/flow/stereoeffectstack_impl.cc
@@ -0,0 +1,179 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "flowsystem.h"
+#include "stdsynthmodule.h"
+#include "debug.h"
+#include <iostream>
+
+using namespace std;
+using namespace Arts;
+
+namespace Arts {
+
+class StereoEffectStack_impl : public StereoEffectStack_skel,
+							   public StdSynthModule
+{
+	long nextID;
+
+	struct EffectEntry {
+		StereoEffect effect;
+		string name;
+		long id;
+	};
+	list<EffectEntry *> fx;
+
+	void xconnect(bool connect, Object from, string fromP, Object to, string toP)
+	{
+		if(connect)
+			from._node()->connect(fromP,to._node(),toP);
+		else
+			from._node()->disconnect(fromP,to._node(),toP);
+	}
+	void xvirtualize(bool connect, string myPort, Object impl, string implPort)
+	{
+		if(connect)
+			_node()->virtualize(myPort,impl._node(),implPort);
+		else
+			_node()->devirtualize(myPort,impl._node(),implPort);
+	}
+	void internalconnect(bool c)
+	{
+		if(fx.empty())
+		{
+			/* no effects - forward input through to output */
+			xvirtualize(c,"outleft",Object::_from_base(this->_copy()),"inleft");
+			xvirtualize(c,"outright",Object::_from_base(this->_copy()),"inright");
+		}
+		else
+		{
+			list<EffectEntry *>::iterator ei;
+			EffectEntry *laste = 0;
+
+			long count = 0;
+			for(ei = fx.begin(); ei != fx.end(); ei++, count++)
+			{
+				EffectEntry *e = *ei;
+				if(count == 0)		/* top of chain? virtualize to effect */
+				{
+					xvirtualize(c,"inleft",e->effect,"inleft");
+					xvirtualize(c,"inright",e->effect,"inright");
+				}
+				else				/* not top? connect last effect to current effect */
+				{
+					xconnect(c,laste->effect,"outleft",e->effect,"inleft");
+					xconnect(c,laste->effect,"outright",e->effect,"inright");
+				}
+				laste = e;
+			}
+			/* end: virtualize effect output to our output */
+			xvirtualize(c,"outleft",laste->effect,"outleft");
+			xvirtualize(c,"outright",laste->effect,"outright");
+		}
+	}
+	void disconnect() { internalconnect(false); }
+	void reconnect()  { internalconnect(true); }
+public:
+	StereoEffectStack_impl() : nextID(1)
+	{
+		reconnect();
+	}
+	~StereoEffectStack_impl()
+	{
+		// disconnect remaining effects
+		EffectEntry *laste = 0;
+		list<EffectEntry *>::iterator ei;
+
+		for(ei = fx.begin(); ei != fx.end(); ei++)
+		{
+			EffectEntry *e = *ei;
+			if(laste)
+			{
+				xconnect(false,laste->effect,"outleft",e->effect,"inleft");
+				xconnect(false,laste->effect,"outright",e->effect,"inright");
+			}
+			laste = e;
+		}
+		// delete remaining effect entries
+		for(ei = fx.begin(); ei != fx.end(); ei++)
+			delete *ei;
+		fx.clear();
+	}
+	long insertTop(StereoEffect effect, const string& name)
+	{
+		arts_return_val_if_fail(!effect.isNull(),0);
+
+		disconnect();
+		EffectEntry *e = new EffectEntry();
+		e->effect = effect;
+		e->name = name;
+		e->id = nextID++;
+		fx.push_front(e);
+		reconnect();
+		return e->id;
+	}
+	long insertBottom(StereoEffect effect, const string& name)
+	{
+		arts_return_val_if_fail(!effect.isNull(),0);
+
+		disconnect();
+		EffectEntry *e = new EffectEntry();
+		e->effect = effect;
+		e->name = name;
+		e->id = nextID++;
+		fx.push_back(e);
+		reconnect();
+		return e->id;
+	}
+
+	void remove(long ID)
+	{
+		arts_return_if_fail(ID != 0);
+
+		bool found = false;
+		disconnect();
+		list<EffectEntry *>::iterator ei = fx.begin();
+		
+		while(ei != fx.end())
+		{
+			if((*ei)->id == ID) {
+				found = true;
+				delete (*ei);
+				fx.erase(ei);
+				ei = fx.begin();
+			}
+			else ei++;
+		}
+		if(!found) {
+			arts_warning("StereoEffectStack::remove failed. id %d not found?",
+							ID);
+		}
+		reconnect();
+	}
+
+	AutoSuspendState autoSuspend() { return asSuspend; }
+};
+
+REGISTER_IMPLEMENTATION(StereoEffectStack_impl);
+
+}
diff --git a/flow/stereofftscope_impl.cc b/flow/stereofftscope_impl.cc
new file mode 100644
index 0000000..59ec05a
--- /dev/null
+++ b/flow/stereofftscope_impl.cc
@@ -0,0 +1,131 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "fft.h"
+#include "stdsynthmodule.h"
+#include <math.h>
+#include <iostream>
+
+using namespace std;
+using namespace Arts;
+
+namespace Arts {
+
+class StereoFFTScope_impl : public StereoFFTScope_skel, public StdSynthModule {
+protected:
+	static const unsigned long SAMPLES = 4096;
+	vector<float> _scope;
+	/*
+	 * some gcc versions expose ugly behaviour with virtual inheritance:
+	 * putting window[4096] & inbuffer[4096] here bloats the vtable then,
+	 * and tells you to recompile with -fhuge-objects ... so allocate them
+	 * dynamically
+	 */
+	float *window;
+	float *inbuffer;
+	unsigned long inbufferpos;
+public:
+	void do_fft()
+	{
+		float out_real[SAMPLES],out_img[SAMPLES];
+		arts_fft_float(SAMPLES,0,inbuffer,0,out_real,out_img);
+
+		_scope.clear();
+    	unsigned int i = 3;
+    	unsigned int j = 0;
+    	for(;;) {
+        	float xrange = 0.0;
+        	while(j != i)
+        	{
+            	xrange += (fabs(out_img[j]) + fabs(out_real[j]))/(float)SAMPLES;
+            	j++;
+        	}
+			_scope.push_back(xrange);
+
+        	if(i == SAMPLES/2) return;
+
+            i += i/2;
+            if(i > SAMPLES/2) i = SAMPLES/2;
+    	}
+	}
+	void streamInit()
+	{
+		unsigned long i;
+		for(i=0;i<SAMPLES;i++)
+		{
+			float x = (float)i/(float)SAMPLES; 
+			window[i] = sin(x*M_PI)*sin(x*M_PI);
+			inbuffer[i] = 0;
+		}
+		do_fft();	// initialize so that we never return an empty scope
+	}
+	void streamStart()
+	{
+		inbufferpos = 0;
+	}
+	vector<float> *scope()
+	{
+		return new vector<float>(_scope);
+	}
+	/*
+	  in audio stream inleft, inright;
+	  out audio stream outleft, outright;
+	*/
+	void calculateBlock(unsigned long samples)
+	{
+		unsigned long i;
+		for(i=0;i<samples;i++)
+		{
+			inbuffer[inbufferpos] =
+				(inleft[i] + inright[i])*window[inbufferpos];
+			if(++inbufferpos == SAMPLES)
+			{
+				do_fft();
+				inbufferpos = 0;
+			}
+			/*
+			   monitoring only tasks can't be done with that StereoEffect
+			   interface nicely - copy input to output until there is
+			   something better
+			 */
+			outleft[i] = inleft[i];
+			outright[i] = inright[i];
+		}
+	}
+
+	/* prevent vtable overflows (see above) */
+	StereoFFTScope_impl() {
+		window = new float[SAMPLES];
+		inbuffer = new float[SAMPLES];
+	}
+	~StereoFFTScope_impl() {
+		delete [] window;
+		delete [] inbuffer;
+	}
+};
+
+const unsigned long StereoFFTScope_impl::SAMPLES;
+
+REGISTER_IMPLEMENTATION(StereoFFTScope_impl);
+
+}
diff --git a/flow/stereovolumecontrol_impl.cc b/flow/stereovolumecontrol_impl.cc
new file mode 100644
index 0000000..ae90ae6
--- /dev/null
+++ b/flow/stereovolumecontrol_impl.cc
@@ -0,0 +1,197 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include <math.h>
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+#include "flowsystem.h"
+#include <debug.h>
+
+#include <cstring>
+
+using namespace Arts;
+
+namespace Arts {
+
+class StereoVolumeControl_impl : virtual public StereoVolumeControl_skel,
+								 virtual public StdSynthModule
+{
+	float _scaleFactor;
+	float _currentVolumeLeft;
+	float _currentVolumeRight;
+	bool _virtualized;
+	bool _calcVolume;
+public:
+	StereoVolumeControl_impl() :_scaleFactor(1.0), _currentVolumeLeft(0.0),
+	                            _currentVolumeRight(0.0), _virtualized( false ),
+	                            _calcVolume( false )
+	{
+		virtualize();
+	}
+
+	/*attribute float scaleFactor;*/
+	void scaleFactor(float newFactor) {
+		if(_scaleFactor != newFactor)
+		{
+			_scaleFactor = newFactor;
+			scaleFactor_changed(newFactor);
+			if( _scaleFactor == 1.0 )
+			{
+				if( !_calcVolume && !_virtualized )
+					virtualize();
+			}
+			else if( _virtualized )
+				devirtualize();
+		}
+	}
+	float scaleFactor() { return _scaleFactor; }
+
+	/*
+	  readonly attribute float currentVolumeLeft;
+	  readonly attribute float currentVolumeRight;
+	*/
+	float currentVolumeLeft()
+	{
+		if( _virtualized && !_calcVolume )
+			needVolumeCalculation();
+
+		return _currentVolumeLeft;
+	}
+
+	float currentVolumeRight()
+	{
+		if( _virtualized && !_calcVolume )
+			needVolumeCalculation();
+
+		return _currentVolumeRight;
+	}
+
+	void needVolumeCalculation()
+	{
+		arts_debug( "calculate Volume in StereoVolumeControl" );
+		_calcVolume = true;
+		devirtualize();
+	}
+
+	void virtualize()
+	{
+		arts_debug( "virtualize StereoVolumeControl" );
+		_virtualized = true;
+		_node()->virtualize( "inleft", _node(), "outleft" );
+		_node()->virtualize( "inright", _node(), "outright" );
+		_currentVolumeRight = _currentVolumeLeft = 0.0;
+	}
+	void devirtualize()
+	{
+		arts_debug( "devirtualize StereoVolumeControl" );
+		_virtualized = false;
+		_node()->devirtualize( "inleft", _node(), "outleft" );
+		_node()->devirtualize( "inright", _node(), "outright" );
+	}
+	/*
+	  in audio stream inleft, inright;
+	  out audio stream outleft, outright;
+	*/
+	void calculateBlock(unsigned long samples)
+	{
+		if( _scaleFactor == 1.0 )
+		{
+			if( _calcVolume )
+			{
+				/*
+				 * make sure that we reach zero sometimes - otherwise there are
+				 * performance issues with calculations close to zero
+				 */
+				if(fabs(_currentVolumeLeft) < 0.001)	_currentVolumeLeft = 0.0;
+				if(fabs(_currentVolumeRight) < 0.001)	_currentVolumeRight = 0.0;
+
+				for( unsigned long i = 0; i < samples; i += 10 )
+				{
+					/* measure volume */
+					float delta;
+
+					// left
+					delta = fabs( outleft[ i ] ) - _currentVolumeLeft;
+					if( delta > 0.0 )
+						_currentVolumeLeft += 0.1 * delta;
+					else
+						_currentVolumeLeft += 0.003 * delta;
+
+					// right
+					delta = fabs( outright[ i ] ) - _currentVolumeRight;
+					if( delta > 0.0 )
+						_currentVolumeRight += 0.1 * delta;
+					else
+						_currentVolumeRight += 0.003 * delta;
+				}
+				memcpy( outleft, inleft, samples * sizeof( float ) );
+				memcpy( outright, inright, samples * sizeof( float ) );
+			}
+			return;
+		}
+
+		unsigned long i;
+
+		/*
+		 * make sure that we reach zero sometimes - otherwise there are
+		 * performance issues with calculations close to zero
+		 */
+		if(fabs(_currentVolumeLeft) < 0.001)	_currentVolumeLeft = 0.0;
+		if(fabs(_currentVolumeRight) < 0.001)	_currentVolumeRight = 0.0;
+
+		for(i=0;i<samples;i++)
+		{
+			/* scale */
+			outleft[i] = inleft[i] * _scaleFactor;
+			outright[i] = inright[i] * _scaleFactor;
+
+			/* measure volume */
+			float delta;
+
+			// left
+			delta = fabs(outleft[i])-_currentVolumeLeft;
+			if(delta > 0.0)
+				_currentVolumeLeft += 0.01 * delta;
+			else
+				_currentVolumeLeft += 0.0003 * delta;
+
+			// right
+			delta = fabs(outright[i])-_currentVolumeRight;
+			if(delta > 0.0)
+				_currentVolumeRight += 0.01 * delta;
+			else
+				_currentVolumeRight += 0.0003 * delta;
+		}
+	}
+
+	AutoSuspendState autoSuspend() {
+		return (_currentVolumeLeft+_currentVolumeRight<0.001)? 
+			asSuspend : asNoSuspend;
+	}
+
+};
+
+REGISTER_IMPLEMENTATION(StereoVolumeControl_impl);
+
+}
+
+// vim: sw=4 ts=4 noet
diff --git a/flow/synth_add_impl.cc b/flow/synth_add_impl.cc
new file mode 100644
index 0000000..1f52a21
--- /dev/null
+++ b/flow/synth_add_impl.cc
@@ -0,0 +1,44 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+
+using namespace Arts;
+
+namespace Arts {
+
+class Synth_ADD_impl :public Synth_ADD_skel, public StdSynthModule
+{
+public:
+	void calculateBlock(unsigned long samples)
+	{
+		unsigned long i;
+
+		for(i = 0;i < samples; i++) 
+			outvalue[i] = invalue1[i] + invalue2[i];
+	}
+};
+
+REGISTER_IMPLEMENTATION(Synth_ADD_impl);
+
+}
diff --git a/flow/synth_frequency_impl.cc b/flow/synth_frequency_impl.cc
new file mode 100644
index 0000000..1c0bbbe
--- /dev/null
+++ b/flow/synth_frequency_impl.cc
@@ -0,0 +1,70 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+#include <math.h>
+#include <stdio.h>
+
+using namespace Arts;
+
+namespace Arts {
+
+class Synth_FREQUENCY_impl :public Synth_FREQUENCY_skel, public StdSynthModule
+{
+	float fpos;
+public:
+	void streamInit() {
+		fpos = 0;
+	}
+	void calculateBlock(unsigned long cycles) {
+		float fsample = samplingRateFloat;
+		float finc = *frequency/fsample;
+
+		while(cycles)
+		{
+			if(cycles >= 8 && ((finc*8+fpos) < 0.9))
+			{
+				fpos += finc; *pos++ = fpos;
+				fpos += finc; *pos++ = fpos;
+				fpos += finc; *pos++ = fpos;
+				fpos += finc; *pos++ = fpos;
+				fpos += finc; *pos++ = fpos;
+				fpos += finc; *pos++ = fpos;
+				fpos += finc; *pos++ = fpos;
+				fpos += finc; *pos++ = fpos;
+				cycles -= 8;
+			}
+			else
+			{
+				fpos += finc;
+				fpos -= floor(fpos);
+				*pos++ = fpos;
+				cycles--;
+			}
+		}
+	}
+};
+
+REGISTER_IMPLEMENTATION(Synth_FREQUENCY_impl);
+
+}
diff --git a/flow/synth_mul_impl.cc b/flow/synth_mul_impl.cc
new file mode 100644
index 0000000..11d97c8
--- /dev/null
+++ b/flow/synth_mul_impl.cc
@@ -0,0 +1,44 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+
+using namespace Arts;
+
+namespace Arts {
+
+class Synth_MUL_impl :public Synth_MUL_skel, public StdSynthModule
+{
+public:
+	void calculateBlock(unsigned long samples)
+	{
+		unsigned long i;
+
+		for(i = 0;i < samples; i++) 
+			outvalue[i] = invalue1[i] * invalue2[i];
+	}
+};
+
+REGISTER_IMPLEMENTATION(Synth_MUL_impl);
+
+}
diff --git a/flow/synth_multi_add_impl.cc b/flow/synth_multi_add_impl.cc
new file mode 100644
index 0000000..2bd14dc
--- /dev/null
+++ b/flow/synth_multi_add_impl.cc
@@ -0,0 +1,64 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+
+using namespace Arts;
+
+namespace Arts {
+
+class Synth_MULTI_ADD_impl :public Synth_MULTI_ADD_skel, public StdSynthModule
+{
+public:
+	void calculateBlock(unsigned long cycles);
+	AutoSuspendState autoSuspend() { return asSuspend; }
+};
+
+REGISTER_IMPLEMENTATION(Synth_MULTI_ADD_impl);
+
+}
+
+void Synth_MULTI_ADD_impl::calculateBlock(unsigned long cycles)
+{
+	float *outend = outvalue + cycles;
+	float *outp, *inp;
+
+	if(!invalue[0])
+	{
+		// no invalue? zero out the outvalue
+		for(outp = outvalue; outp != outend; outp++) *outp = 0.0;
+	}
+	else
+	{
+		// copy first signal
+		for(outp = outvalue, inp = invalue[0]; outp != outend; outp++, inp++)
+			*outp = *inp;
+
+		// add the others
+		for(int sig=1;(inp = invalue[sig]) != 0;sig++)
+		{
+			for(outp = outvalue; outp != outend;outp++,inp++)
+				*outp += *inp;
+		}
+	}
+}
diff --git a/flow/synth_play_impl.cc b/flow/synth_play_impl.cc
new file mode 100644
index 0000000..c1be750
--- /dev/null
+++ b/flow/synth_play_impl.cc
@@ -0,0 +1,285 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "debug.h"
+#include "convert.h"
+#include "objectmanager.h"
+#include "audiosubsys.h"
+#include "dispatcher.h"
+#include "iomanager.h"
+#include "flowsystem.h"
+#include "stdsynthmodule.h"
+#include <stdio.h>
+#include <iostream>
+
+using namespace std;
+using namespace Arts;
+
+namespace Arts {
+
+class Synth_PLAY_impl :	virtual public Synth_PLAY_skel,
+						virtual public ASProducer,
+						virtual public StdSynthModule,
+						virtual public IONotify,
+						virtual public TimeNotify
+{
+protected:
+	AudioSubSystem *as;
+	bool haveSubSys;
+	/*
+	 * these are to prevent the following situation
+	 * 1) audio subsystem needs more data
+	 * 2) calculation is started
+	 * 3) somehow, some module makes a synchronous invocation to the outside
+	 *    world and waits for the result
+	 * 4) since the audio subsystem still needs data, and since we are in an
+	 *    idle state now, another calculation will be started, which will of
+	 *    course fail due to reentrancy
+	 * 5) repeat 4) until result is there => lots of wasted CPU cycles (when
+	 *    running with realtime priority: system freeze)
+	 */
+	bool inProgress;		// we are just doing some calculations
+	bool restartIOHandling;	// I/O handlers removed upon reaching 4: restart
+
+	int audioReadFD;
+	int audioWriteFD;
+	bool audioOpen;
+
+	typedef unsigned char uchar;
+
+	unsigned char *outblock;
+	unsigned long maxsamples;
+	unsigned long channels;
+	int format;
+	int bits;
+
+	bool retryOpen;
+public:
+	/*
+	 * functions from the SynthModule interface (which is inherited by
+	 * SynthPlay)
+	 */
+	void streamInit() {
+		as = AudioSubSystem::the();
+
+		maxsamples = 0;
+		outblock = 0;
+		retryOpen = false;
+		audioOpen = false;
+		inProgress = false;
+
+		haveSubSys = as->attachProducer(this);
+		if(!haveSubSys)
+		{
+			arts_info("Synth_PLAY: audio subsystem is already used");
+			return;
+		}
+
+		audioOpen = as->open();
+		if(!audioOpen)
+		{
+			if(Dispatcher::the()->flowSystem()->suspended())
+			{
+				arts_info("/dev/dsp currently unavailable (retrying)");
+				Dispatcher::the()->ioManager()->addTimer(1000, this);
+				retryOpen = true;
+			}
+			else
+			{
+				arts_info("Synth_PLAY: audio subsystem init failed");
+				arts_info("ASError = %s",as->error());
+			}
+			audioReadFD = audioWriteFD = -1;
+		}
+		else
+		{
+			audioReadFD = as->selectReadFD();
+			audioWriteFD = as->selectWriteFD();
+		}
+
+		channels = as->channels();
+		format = as->format();
+		bits = as->bits();
+		arts_debug("audio format is %d Hz, %d bits, %d channels",
+					as->samplingRate(), bits, channels);
+	}
+
+	void notifyTime() {
+		assert(retryOpen);
+
+		audioOpen = as->open();
+
+		if(audioOpen)
+		{
+			audioReadFD = as->selectReadFD();
+			audioWriteFD = as->selectWriteFD();
+
+			streamStart();
+			arts_info("/dev/dsp ok");
+			Dispatcher::the()->ioManager()->removeTimer(this);
+			retryOpen = false;
+		}
+	}
+
+	void streamStart() {
+		IOManager *iom = Dispatcher::the()->ioManager();
+
+		if(audioReadFD >= 0)
+			iom->watchFD(audioReadFD, IOType::read|IOType::except, this);
+
+		if(audioWriteFD >= 0)
+			iom->watchFD(audioWriteFD, IOType::write|IOType::except, this);
+	}
+
+	void streamEnd() {
+		if(retryOpen)
+			Dispatcher::the()->ioManager()->removeTimer(this);
+
+		arts_debug("Synth_PLAY: closing audio fd");
+		if(audioReadFD >= 0 || audioWriteFD >= 0)
+		{
+			IOManager *iom = Dispatcher::the()->ioManager();
+			iom->remove(this,IOType::all);
+			audioReadFD = audioWriteFD = -1;
+		}
+		AudioSubSystem::the()->detachProducer();
+
+		if(outblock)
+		{
+			delete[] outblock;
+			outblock = 0;
+		}
+	}
+
+	AutoSuspendState autoSuspend()
+	{
+		return static_cast<AutoSuspendState>(asSuspendStop|asConsumer);
+	}
+
+	void calculateBlock(unsigned long samples)
+	{
+		// no audio subsystem, no play
+		if(!as->running() || !haveSubSys) return;
+
+		if(samples > maxsamples)
+		{
+			maxsamples = samples;
+
+			if(outblock) delete[] outblock;
+			outblock = new uchar[maxsamples * channels * ( format & ( 8 | 16 | 32 ) ) / 8];
+		}
+
+		assert(channels);
+
+		arts_assert(format == 8 || format == 16 || format == 17 || format == 32 );
+		if(channels == 1)
+		{
+			if(format == 8)
+				convert_mono_float_8(samples,invalue_left,outblock);
+			else if(format == 16)
+				convert_mono_float_16le(samples,invalue_left,outblock);
+			else if(format == 17)
+				convert_mono_float_16be(samples,invalue_left,outblock);
+			else if(format == 32)
+			{
+				as->write( invalue_left, samples );
+				return;
+			}
+		}
+		else if(channels == 2)
+		{
+			if(format == 8)
+				convert_stereo_2float_i8(samples,invalue_left,invalue_right,
+													outblock);
+			else if(format == 16)
+				convert_stereo_2float_i16le(samples,invalue_left,invalue_right,
+													outblock);
+			else if(format == 17)
+				convert_stereo_2float_i16be(samples,invalue_left,invalue_right,
+													outblock);
+			else if(format == 32)
+			{
+				float * buffer = ( float* )outblock;
+				float * end = invalue_left + samples;
+				while( invalue_left < end )
+				{
+					*buffer++ = *invalue_left++;
+					*buffer++ = *invalue_right++;
+				}
+				as->write( outblock, 2 * samples * sizeof( float ) );
+				return;
+			}
+		}
+		else arts_warning("channels != 1 && channels != 2?");
+
+		as->write(outblock,channels * (bits / 8) * samples);
+	}
+
+	/**
+	 * notifyIO from the IONotify interface (IOManager)
+	 */
+	void notifyIO(int fd, int type)
+	{
+		arts_return_if_fail(as->running());
+		assert(fd == audioReadFD || fd == audioWriteFD);
+
+		if(inProgress)
+		{
+			if(!restartIOHandling)
+			{
+				// prevent lots of retries - we just can't do calculations
+				// now, so we need to wait until the situation has resolved
+				Dispatcher::the()->ioManager()->remove(this,IOType::all);
+				restartIOHandling = true;
+			}
+			return;
+		}
+
+		// convert iomanager notification types to audiosubsys notification
+		int asType = 0;
+
+		if(type & IOType::read)		asType |= AudioSubSystem::ioRead;
+		if(type & IOType::write)	asType |= AudioSubSystem::ioWrite;
+		assert(asType != 0);
+
+		restartIOHandling = false;
+		inProgress = true;
+		as->handleIO(asType);
+		inProgress = false;
+		if(restartIOHandling) streamStart();
+	}
+
+	/**
+	 * needmore from the ASProducer interface (AudioSubSystem)
+	 */
+	void needMore()
+	{
+		_node()->requireFlow();
+	}
+	
+};
+
+REGISTER_IMPLEMENTATION(Synth_PLAY_impl);
+
+}
+// vim: sw=4 ts=4 noet
diff --git a/flow/synth_play_wav_impl.cc b/flow/synth_play_wav_impl.cc
new file mode 100644
index 0000000..d94703c
--- /dev/null
+++ b/flow/synth_play_wav_impl.cc
@@ -0,0 +1,579 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "config.h"
+#ifdef HAVE_LIBAUDIOFILE
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+#include "debug.h"
+#include "cachedwav.h"
+#include "convert.h"
+#include <stdio.h>
+#include <iostream>
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+
+extern "C" {
+/* Some versions of libaudiofile seem to lack the extern "C" declaration,
+ * so you you may need that extra one.
+ *
+ * Other versions of libaudiofile seem to have two closing "}" in aupvlist.h,
+ * so if you can't compile, this, check that /usr/include/aupvlist.h contains
+ * something like that
+ *
+ * #ifdef __cplusplus
+ * }
+ * #endif 
+ *
+ * only once not twice.
+ */
+#include "audiofile.h"
+}
+
+#include <sys/stat.h>
+#include <unistd.h>
+
+using namespace std;
+using namespace Arts;
+
+
+CachedWav *CachedWav::load(Cache *cache, string filename)
+{
+	CachedWav *wav;
+
+	wav = (CachedWav *)cache->get(string("CachedWav:")+filename);
+	if(!wav) {
+		wav = new CachedWav(cache,filename);
+
+		if(!wav->initOk)		// loading failed
+		{
+			wav->decRef();
+			return 0;
+		}
+	}
+
+	return(wav);
+}
+
+bool CachedWav::isValid()
+{
+	if(!initOk)
+		return false;
+
+	struct stat newstat;
+
+	lstat(filename.c_str(),&newstat);
+	return(newstat.st_mtime == oldstat.st_mtime);
+}
+
+int CachedWav::memoryUsage()
+{
+	return(bufferSize);
+}
+
+CachedWav::CachedWav(Cache *cache, string filename) : CachedObject(cache),
+								 filename(filename),initOk(false), buffer(0)
+{
+	int sampleFormat;
+	AFframecount	frameCount;
+	AFfilehandle	file;
+
+	setKey(string("CachedWav:")+filename);
+
+	if(lstat(filename.c_str(),&oldstat) == -1)
+	{
+		arts_info("CachedWav: Can't stat file '%s'", filename.c_str());
+		return;
+	}
+
+	file = afOpenFile(filename.c_str(), "r", NULL);
+	if(!file)
+	{
+		arts_info("CachedWav: Can't read file '%s'", filename.c_str());
+		return;
+	}
+
+	frameCount = afGetFrameCount(file, AF_DEFAULT_TRACK);
+	if(frameCount <= 0 || frameCount >= INT_MAX)
+	{
+		arts_info("CachedWav: Invalid length for '%s'", filename.c_str());
+		afCloseFile(file);
+		return;
+	}
+
+	channelCount = afGetChannels(file, AF_DEFAULT_TRACK);
+	afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
+
+	// we want everything converted to little endian unconditionally
+	afSetVirtualByteOrder(file,AF_DEFAULT_TRACK, AF_BYTEORDER_LITTLEENDIAN);
+
+	arts_debug("loaded wav %s",filename.c_str());
+	arts_debug("  sample format: %d, sample width: %d",
+		sampleFormat,sampleWidth);
+	arts_debug("   channelCount: %d",channelCount);
+	arts_debug("     frameCount: %d",frameCount);
+
+	// different handling required for other sample widths
+	assert(sampleWidth == 16 || sampleWidth == 8);
+
+	long frameSize = (sampleWidth/8)*channelCount;
+	samplingRate = afGetRate(file, AF_DEFAULT_TRACK);
+
+	/*
+	 * if we don't know the track bytes, we'll have to figure out ourselves
+	 * how many frames are stored here - it would be nicer if libaudiofile
+	 * let us know somehow whether the value returned for getFrameCount
+	 * means "don't know" or is really the correct length
+	 */
+	int trackBytes = afGetTrackBytes(file, AF_DEFAULT_TRACK);
+	if(trackBytes == -1)
+	{
+		arts_debug("unknown length");
+		long fcount = 0, f = 0;
+
+		list<void *> blocks;
+		do
+		{
+			void *block = malloc(1024 * frameSize);
+
+			f = afReadFrames(file, AF_DEFAULT_TRACK,block,1024);
+			if(f > 0)
+			{
+				fcount += f;
+				blocks.push_back(block);
+			}
+			else
+			{
+				free(block);
+			}
+		} while(f > 0);
+
+		frameCount = fcount;
+		arts_debug("figured out frameCount = %ld", fcount);
+
+		bufferSize = frameCount * frameSize;
+		buffer = new uchar[bufferSize];
+		assert(buffer);
+
+		// reassemble and free the blocks
+		while(!blocks.empty())
+		{
+			void *block = blocks.front();
+			blocks.pop_front();
+
+			f = (fcount>1024)?1024:fcount;
+			memcpy(&buffer[(frameCount-fcount)*frameSize],block,f*frameSize);
+			fcount -= f;
+		}
+		assert(fcount == 0);
+	}
+	else
+	{
+		bufferSize = frameCount * frameSize;
+		buffer = new uchar[bufferSize];
+		assert(buffer);
+
+		afReadFrames(file, AF_DEFAULT_TRACK,buffer,frameCount);
+	}
+
+	afCloseFile(file);
+	initOk = true;
+}
+
+CachedWav::~CachedWav()
+{
+	if(buffer)
+		delete[] buffer;
+}
+
+namespace Arts {
+
+class Synth_PLAY_WAV_impl : public Synth_PLAY_WAV_skel, public StdSynthModule {
+protected:
+	double flpos;
+
+	float _speed;
+	string _filename;
+	bool _finished;
+	CachedWav *cachedwav;
+
+	void unload()
+	{
+		if(cachedwav)
+		{
+			cachedwav->decRef();
+			cachedwav = 0;
+		}
+	}
+
+	void load()
+	{
+		// unload the old file if necessary
+		unload();
+
+		// load the new (which will reset the position)
+		cachedwav = CachedWav::load(Cache::the(), _filename);
+		flpos = 0.0;
+	}
+
+public:
+	float speed() { return _speed; }
+	void speed(float newSpeed) { _speed = newSpeed; }
+
+	string filename() { return _filename; }
+	void filename(const string& filename) { _filename = filename; load(); }
+
+	void finished(bool f)
+	{
+		if(_finished != f)
+		{
+			_finished = f;
+			finished_changed(f);
+		}
+	}
+	bool finished() { return _finished; }
+
+	Synth_PLAY_WAV_impl();
+	~Synth_PLAY_WAV_impl();
+
+	void streamInit();
+	void calculateBlock(unsigned long samples);
+};
+
+REGISTER_IMPLEMENTATION(Synth_PLAY_WAV_impl);
+
+}
+
+Synth_PLAY_WAV_impl::Synth_PLAY_WAV_impl()
+{
+	cachedwav = 0;
+	_speed = 1.0;
+	_filename = "";
+	_finished = false;
+}
+
+Synth_PLAY_WAV_impl::~Synth_PLAY_WAV_impl()
+{
+	unload();
+}
+
+void Synth_PLAY_WAV_impl::streamInit()
+{
+	finished(false);
+}
+
+void Synth_PLAY_WAV_impl::calculateBlock(unsigned long samples)
+{
+	unsigned long haveSamples = 0;
+
+	if(cachedwav)
+	{
+		double speed = cachedwav->samplingRate / samplingRateFloat * _speed;
+
+		haveSamples = uni_convert_stereo_2float(samples, cachedwav->buffer,
+		   cachedwav->bufferSize,cachedwav->channelCount,cachedwav->sampleWidth,
+		   left,right,speed,flpos);
+
+		flpos += (double)haveSamples * speed;
+	}
+
+	if(haveSamples != samples)
+	{
+		unsigned long i;
+
+		for(i=haveSamples;i<samples;i++)
+			left[i] = right[i] = 0.0;
+
+		finished(true);
+	}
+
+/*
+	float speed = 0.0;
+	unsigned long haveSamples = 0;
+
+	if(cachedwav)
+	{
+		float allSamples = cachedwav->bufferSize*8 /
+	    				   cachedwav->sampleWidth/cachedwav->channelCount;
+		float fHaveSamples = allSamples - flpos;
+
+		speed = cachedwav->samplingRate / (float)samplingRate * _speed;
+
+		fHaveSamples /= speed;
+		fHaveSamples -= 2.0;	// one due to interpolation and another against
+								// rounding errors
+		if(fHaveSamples > 0)
+		{
+			haveSamples = (int)fHaveSamples;
+			if(haveSamples > samples) haveSamples = samples;
+		}
+	}
+
+	if(haveSamples)				// something left to play?
+	{
+		if(cachedwav->channelCount == 1)
+		{
+			if(cachedwav->sampleWidth == 16) {
+				interpolate_mono_16le_float(haveSamples,
+							flpos,speed,cachedwav->buffer,left);
+			}
+			else {
+				interpolate_mono_8_float(haveSamples,
+							flpos,speed,cachedwav->buffer,left);
+			}
+			memcpy(right,left,sizeof(float)*haveSamples);
+		}
+		else if(cachedwav->channelCount == 2)
+		{
+			if(cachedwav->sampleWidth == 16) {
+				interpolate_stereo_i16le_2float(haveSamples,
+							flpos,speed,cachedwav->buffer,left,right);
+			}
+			else {
+				interpolate_stereo_i8_2float(haveSamples,
+							flpos,speed,cachedwav->buffer,left,right);
+			}
+		} else {
+			assert(false);
+		}
+
+		flpos += (float)haveSamples * speed;
+	}
+
+	if(haveSamples != samples)
+	{
+		unsigned long i;
+
+		for(i=haveSamples;i<samples;i++)
+			left[i] = right[i] = 0.0;
+
+		_finished = true;
+	}
+*/
+}
+
+
+#if 0
+class Synth_PLAY_WAV :public SynthModule {
+protected:
+	CachedWav *cachedwav;
+
+	unsigned char *buffer;
+	int channelCount;
+	unsigned long bufferSize, position, bytesPerSample;
+
+	// inputs:
+	enum { PROP_FILENAME };
+
+	// outputs:
+	enum { LEFT, RIGHT, DONE };
+
+public:
+	void Initialize();
+	void DeInitialize();
+	void Calculate() { assert(false); }
+	void CalculateBlock(unsigned long samples);
+	string getParams() { return("_filename;left,right,done"); }
+	static void *Creator() { return new Synth_PLAY_WAV; }
+};
+
+ModuleClient MC_Synth_PLAY_WAV(SynthModule::get_MS,"Synth_PLAY_WAV",Synth_PLAY_WAV::Creator);
+
+void Synth_PLAY_WAV::CalculateBlock(unsigned long samples)
+{
+	unsigned long haveSamples = samples;
+	unsigned long remainingSamples;
+
+	remainingSamples = (bufferSize-position)/bytesPerSample;
+	if(haveSamples > remainingSamples) haveSamples = remainingSamples;
+
+	float *left = out[LEFT], *right = out[RIGHT], *done = out[DONE];
+	unsigned long i;
+
+	if(haveSamples)
+	{
+		if(channelCount == 1)
+		{
+			if(bytesPerSample == 2) {
+				convert_mono_16le_float(haveSamples,&buffer[position],left);
+			}
+			else {
+				convert_mono_8_float(haveSamples,&buffer[position],left);
+			}
+			memcpy(right,left,sizeof(float)*haveSamples);
+		}
+		else if(channelCount == 2)
+		{
+			if(bytesPerSample == 2) {
+				convert_stereo_i16le_2float(haveSamples,&buffer[position],
+																	left,right);
+			}
+			else {
+				convert_stereo_i8_2float(haveSamples,&buffer[position],
+																	left,right);
+			}
+		} else {
+			assert(false);
+		}
+
+		for(i=0;i<haveSamples;i++) done[i] = 0.0;
+
+		position += bytesPerSample*channelCount*haveSamples;
+	}
+
+	for(i=haveSamples;i<samples;i++)
+	{
+		left[i] = right[i] = 0.0; done[i] = 1.0;		// ready, kill me ;)
+	}
+}
+
+void Synth_PLAY_WAV::DeInitialize()
+{
+	cachedwav->decRef();
+}
+
+void Synth_PLAY_WAV::Initialize()
+{
+	cachedwav = CachedWav::load(Synthesizer->getCache(),
+									getStringProperty(PROP_FILENAME));
+
+	// may take some speed to access cachedwav every time
+	bufferSize = cachedwav->bufferSize;	
+	channelCount = cachedwav->channelCount;
+	buffer = cachedwav->buffer;
+	bytesPerSample = cachedwav->sampleWidth/8;
+
+	haveCalculateBlock = true;
+	position = 0;
+}
+
+class Synth_PLAY_PITCHED_WAV :public SynthModule {
+protected:
+	CachedWav *cachedwav;
+	float flpos;
+
+	// inputs:
+	enum { FREQUENCY,RECFREQUENCY, PROP_FILENAME };
+
+	// outputs:
+	enum { LEFT, RIGHT, DONE };
+
+public:
+	void Initialize();
+	void DeInitialize();
+	void Calculate() { assert(false); }
+	void CalculateBlock(unsigned long samples);
+	string getParams() { return("frequency,recfrequency,_filename;left,right,done"); }
+	static void *Creator() { return new Synth_PLAY_PITCHED_WAV; }
+};
+
+ModuleClient MC_Synth_PLAY_PITCHED_WAV(SynthModule::get_MS,"Synth_PLAY_PITCHED_WAV",Synth_PLAY_PITCHED_WAV::Creator);
+
+void Synth_PLAY_PITCHED_WAV::CalculateBlock(unsigned long samples)
+{
+	float frequency = in[FREQUENCY][0], recfrequency = in[RECFREQUENCY][0];
+	float allSamples = cachedwav->bufferSize*8 /
+	                   cachedwav->sampleWidth/cachedwav->channelCount;
+	float fHaveSamples = allSamples - flpos;
+	float speed = cachedwav->samplingRate / (float)samplingRate *
+				  frequency / recfrequency;
+
+	fHaveSamples /= speed;
+	fHaveSamples -= 2.0;		// one due to interpolation and another against
+							// rounding errors
+
+	unsigned long haveSamples;
+
+	if(fHaveSamples < 0)
+	{
+		haveSamples = 0;
+	}
+	else
+	{
+		haveSamples = fHaveSamples;
+		if(haveSamples > samples) haveSamples = samples;
+	}
+
+	float *left = out[LEFT], *right = out[RIGHT], *done = out[DONE];
+	unsigned long i;
+
+	if(haveSamples)
+	{
+		if(cachedwav->channelCount == 1)
+		{
+			if(cachedwav->sampleWidth == 16) {
+				interpolate_mono_16le_float(haveSamples,
+							flpos,speed,cachedwav->buffer,left);
+			}
+			else {
+				interpolate_mono_8_float(haveSamples,
+							flpos,speed,cachedwav->buffer,left);
+			}
+			memcpy(right,left,sizeof(float)*haveSamples);
+		}
+		else if(cachedwav->channelCount == 2)
+		{
+			if(cachedwav->sampleWidth == 16) {
+				interpolate_stereo_i16le_2float(haveSamples,
+							flpos,speed,cachedwav->buffer,left,right);
+			}
+			else {
+				interpolate_stereo_i8_2float(haveSamples,
+							flpos,speed,cachedwav->buffer,left,right);
+			}
+		} else {
+			assert(false);
+		}
+
+		for(i=0;i<haveSamples;i++) done[i] = 0.0;
+
+		flpos += (float)haveSamples * speed;
+	}
+
+	for(i=haveSamples;i<samples;i++)
+	{
+		left[i] = right[i] = 0.0; done[i] = 1.0;		// ready, kill me ;)
+	}
+}
+
+void Synth_PLAY_PITCHED_WAV::DeInitialize()
+{
+	cachedwav->decRef();
+}
+
+void Synth_PLAY_PITCHED_WAV::Initialize()
+{
+	cachedwav = CachedWav::load(Synthesizer->getCache(),
+									getStringProperty(PROP_FILENAME));
+
+	haveCalculateBlock = true;
+	flpos = 0.0;
+}
+#endif
+
+#else
+#ifdef __GNUC__
+#warning "No libaudiofile available, that means, you won't be able to play wavs"
+#endif
+#endif
+
diff --git a/flow/synth_record_impl.cc b/flow/synth_record_impl.cc
new file mode 100644
index 0000000..a159bee
--- /dev/null
+++ b/flow/synth_record_impl.cc
@@ -0,0 +1,184 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "debug.h"
+#include "convert.h"
+#include "objectmanager.h"
+#include "audiosubsys.h"
+#include "dispatcher.h"
+#include "iomanager.h"
+#include "flowsystem.h"
+#include "stdsynthmodule.h"
+#include <stdio.h>
+#include <iostream>
+#include <cstring>
+
+#undef DEBUG_WAVEFORM
+#ifdef DEBUG_WAVEFORM
+#include <fstream>
+#endif
+
+using namespace std;
+using namespace Arts;
+
+namespace Arts {
+
+class Synth_RECORD_impl :	virtual public Synth_RECORD_skel,
+						virtual public ASConsumer,
+						virtual public StdSynthModule
+{
+#ifdef DEBUG_WAVEFORM
+	ofstream plotfile;
+#endif
+protected:
+	AudioSubSystem *as;
+	bool haveSubSys;
+
+	typedef unsigned char uchar;
+
+	unsigned char *inblock;
+	unsigned long maxsamples;
+	unsigned long channels;
+	int format;
+	int bits;
+
+public:
+#ifdef DEBUG_WAVEFORM
+	Synth_RECORD_impl()
+		: plotfile( "/dev/shm/synth_record.plot" )
+	{
+	}
+#endif
+	/*
+	 * functions from the SynthModule interface (which is inherited by
+	 * SynthPlay)
+	 */
+	void streamInit() {
+		as = AudioSubSystem::the();
+
+		channels = as->channels();
+		format = as->format();
+		bits = as->bits();
+		maxsamples = 0;
+		inblock = 0;
+
+		haveSubSys = as->attachConsumer(this);
+		if(!haveSubSys)
+		{
+			arts_info("Synth_RECORD: audio subsystem is already used");
+			return;
+		}
+	}
+
+	void streamEnd() {
+		arts_debug("Synth_RECORD: detaching");
+		if(haveSubSys) as->detachConsumer();
+
+		if(inblock)
+		{
+			delete[] inblock;
+			inblock = 0;
+		}
+	}
+
+	AutoSuspendState autoSuspend()
+	{
+		return static_cast<AutoSuspendState>(asSuspend|asProducer);
+	}
+
+	void calculateBlock(unsigned long samples)
+	{
+		// no audio subsystem, no play
+		if(!as->running() || !haveSubSys) return;
+
+		if(samples > maxsamples)
+		{
+			maxsamples = samples;
+
+			if(inblock) delete[] inblock;
+			inblock = new uchar[maxsamples * channels * bits / 8];
+		}
+
+		assert(channels);
+
+		as->read(inblock,channels * (bits/8) * samples);
+
+		arts_assert(format == 8 || format == 16 || format == 17 || format == 32);
+		if(format == 8)
+		{
+			if(channels == 1)
+				convert_mono_8_float(samples,inblock,left);
+
+			if(channels == 2)
+				convert_stereo_i8_2float(samples,inblock,left,right);
+		}
+		else if(format == 16)
+		{
+			if(channels == 1)
+				convert_mono_16le_float(samples,inblock,left);
+
+			if(channels == 2)
+				convert_stereo_i16le_2float(samples,inblock,left,right);
+		}
+		else if(format == 17)
+		{
+			if(channels == 1)
+				convert_mono_16be_float(samples,inblock,left);
+
+			if(channels == 2)
+				convert_stereo_i16be_2float(samples,inblock,left,right);
+		}
+		else if(format == 32)
+		{
+			if(channels == 2)
+			{
+				float * end = (float *)(inblock + 8 * samples);
+				float * floatbuffer = (float *)inblock;
+				while(floatbuffer < end)
+				{
+#ifdef DEBUG_WAVEFORM
+					plotfile << *floatbuffer << "\n";
+#endif
+					*left++ = *floatbuffer++;
+					*right++ = *floatbuffer++;
+				}
+			}
+			else if(channels == 1)
+				memcpy(left, inblock, samples);
+		}
+	}
+
+	/**
+	 * havemore from the ASConsumer interface (AudioSubSystem)
+	 */
+	void haveMore()
+	{
+		_node()->requireFlow();
+	}
+};
+
+REGISTER_IMPLEMENTATION(Synth_RECORD_impl);
+
+}
+
+// vim: sw=4 ts=4
diff --git a/flow/synth_wave_sin_impl.cc b/flow/synth_wave_sin_impl.cc
new file mode 100644
index 0000000..62e2f03
--- /dev/null
+++ b/flow/synth_wave_sin_impl.cc
@@ -0,0 +1,44 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "artsflow.h"
+#include "stdsynthmodule.h"
+#include <math.h>
+
+using namespace Arts;
+
+namespace Arts {
+
+class Synth_WAVE_SIN_impl : virtual public Synth_WAVE_SIN_skel,
+							virtual public StdSynthModule
+{
+public:
+	void calculateBlock(unsigned long cycles)
+	{
+		for(unsigned long i=0; i<cycles; i++)
+			outvalue[i] = sin(pos[i]*2*M_PI);
+	}
+};
+
+REGISTER_IMPLEMENTATION(Synth_WAVE_SIN_impl);
+
+}
diff --git a/flow/synthschedule.h b/flow/synthschedule.h
new file mode 100644
index 0000000..f44667a
--- /dev/null
+++ b/flow/synthschedule.h
@@ -0,0 +1,36 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#ifndef SYNTHSCHEDULE_H
+#define SYNTHSCHEDULE_H
+
+#include "config.h"
+
+#ifdef __GNUC__
+#warning " *   <synthschedule.h> included!   *"
+#warning " * include <gslschedule.h> instead *"
+#endif
+
+#include "gslschedule.h"
+
+#endif // SYNTHSCHEDULE_H
+
diff --git a/flow/virtualports.cc b/flow/virtualports.cc
new file mode 100644
index 0000000..76b5087
--- /dev/null
+++ b/flow/virtualports.cc
@@ -0,0 +1,491 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+#include "virtualports.h"
+#include <algorithm>
+#include <stdio.h>
+
+using namespace Arts;
+using namespace std;
+
+#undef VPORT_DEBUG
+
+/* virtual port connections */
+
+/*
+
+Port virtualization is used in the following case: suppose you have a module
+M which has an input port and an output port like that:
+
+input
+  V
+-----
+  M
+-----
+  V
+output
+
+But suppose the module M is implement as combination of other modules, for
+instance the effect of M is achieved by passing the signal first through an
+A and then through an B module. Clients connecting M should "really" connect
+A,B. For this virtualization is used.
+
+There are two kinds:
+
+- masquerading: which means (like in our case), the input of a module is really
+  implemented with the input of another module. So M's input could be really
+  implemented by A's input
+
+  there is also output masquerading, which would be for instance that M's
+  output is really implemented by B's output
+
+- forwarding: if M in our example would choose to do nothing at all, it could
+  simply forward its input to its output
+
+
+The interface for the user:
+
+MCOP will show the virtualize function to the user, which the user can use
+to delegate the services of a port to another module onto another port.
+
+- masquerading: in our case, for instance the user could call
+
+    m._node()->virtualize("inputport",a._node(),"inputport");
+
+  which would forward all input m gets on "inputport" to a's "inputport"
+
+- forwarding: in the same way, the user could call
+
+    m._node()->virtualize("inputport",m._node(),"outputport");
+
+  which would make m forward its input directly to its output
+
+The implementation:
+
+Virtualization is implemented here, inside the flow system, using a fairly
+complex forwarding strategy, which will have a graph which contains
+
+- "user-made" connections (made with connect())
+- "virtualize-made" connections, which can be either forwarding
+  (input to output port) or masquerading (input to input or output to output)
+ 
+Out of all these, the algorithm builds "real" connections, which are
+then really performed inside the flow system. If you change the "user-made"
+or "virtualize-made" connections, the "real" connections are recalculated.
+
+The "real" connections are created by the expandHelper function. They are
+called vcTransport here.
+
+The strategy expandHelper uses is to go back to a port which is only output
+port (non forwarded, non masqueraded), and then follow the graph recursively
+over vcMasquerade and vcForward edges until it reaches a port which is only
+input. Then it creates a real connection.
+
+Some tweaks are there which allow that not on any change at the graph, all
+real connections will be removed, but only these that could possibly be
+affected by this change, and then not all real connections are created new,
+but only those that could possibly be created by this virtual connection.
+
+Every VPort contains a pointer to the "real" port, to let the flow system
+know where the "real" connections where real data will flow must be made.
+
+*/
+
+VPortConnection::VPortConnection(VPort *source, VPort *dest, Style style)
+		:source(source),dest(dest),style(style)
+{
+	if(style != vcTransport)
+	{
+		list<VPortConnection *>::iterator i;
+
+		// remove transport connections ending at "source" (they will 
+		// probably be forwarded/masqueraded elsewhere by this VPortConnection)
+		i = source->incoming.begin();
+		while(i != source->incoming.end())
+		{
+			if((*i)->style == vcTransport)
+			{
+				delete *i;
+				i = source->incoming.begin();
+			}
+			else i++;
+		}
+
+		// remove transport connections starting at "dest" (they will 
+		// probably be forwarded/masqueraded elsewhere by this VPortConnection)
+		i = dest->outgoing.begin();
+		while(i != dest->outgoing.end())
+		{
+			if((*i)->style == vcTransport)
+			{
+				delete *i;
+				i = dest->outgoing.begin();
+			}
+			else i++;
+		}
+	}
+
+	// add to the connection lists
+	source->outgoing.push_back(this);
+	dest->incoming.push_back(this);
+
+	if(style == vcTransport)
+	{
+#ifdef VPORT_DEBUG
+		arts_debug("emit a connection consumer = %s, producer = %s",
+			dest->name(), source->name());
+#endif
+		dest->port->connect(source->port);
+	}
+	else
+	{
+		source->makeTransport(this);
+	}
+}
+
+VPortConnection::~VPortConnection()
+{
+#ifdef VPORT_DEBUG
+	cout << "~VPortConnection" << endl;
+#endif
+
+	if(style != vcTransport)
+	{
+		// remove transport connection which go through this connection
+		source->removeTransport(this);
+	}
+
+	// remove this connection from the lists
+	list<VPortConnection *>::iterator ci;
+
+	ci = find(source->outgoing.begin(),source->outgoing.end(),this);
+	assert(ci != source->outgoing.end());
+	source->outgoing.erase(ci);
+
+	ci = find(dest->incoming.begin(),dest->incoming.end(),this);
+	assert(ci != dest->incoming.end());
+	dest->incoming.erase(ci);
+
+	if(style == vcTransport)
+	{
+#ifdef VPORT_DEBUG
+		arts_debug("delete connection %s -> %s",dest->name(), source->name());
+#endif
+		dest->port->disconnect(source->port);
+	}
+
+	// reestablish all connections which started/ended here before
+	if(style != vcTransport)
+	{
+		list<VPortConnection *>::iterator i;
+		stack<VPortConnection *> todo;
+
+		// reestablish transport connections which were ending at source...
+		for(i = source->incoming.begin(); i != source->incoming.end(); i++)
+			if((*i)->style != vcTransport) todo.push(*i);
+
+		// ... and starting at dest
+		for(i = dest->outgoing.begin(); i != dest->outgoing.end(); i++)
+			if((*i)->style != vcTransport) todo.push(*i);
+
+		// we need to do this with the stack as makeTransport can affect the
+		// incoming/outgoing lists by adding new vcTransport connections
+		while(!todo.empty())
+		{
+			todo.top()->source->makeTransport(todo.top());
+			todo.pop();
+		}
+	}
+
+#ifdef VPORT_DEBUG
+	cout << "~VPortConnection done" << endl;
+#endif
+}
+
+/*---------------------- virtual port implementation ----------------------*/
+
+VPort::VPort(Port *port) :port(port)
+{
+#ifdef VPORT_DEBUG
+	cout << "VPort: " << name() << endl;
+#endif
+}
+
+VPort::~VPort()
+{
+#ifdef VPORT_DEBUG
+	cout << "~VPort: " << name() << endl;
+#endif
+	while(!incoming.empty()) delete *incoming.begin();
+	while(!outgoing.empty()) delete *outgoing.begin();
+#ifdef VPORT_DEBUG
+	cout << "~VPort done" << endl;
+#endif
+}
+
+bool VPort::makeVirtualizeParams(VPort *forward, VPort*& source, VPort*& dest,
+	VPortConnection::Style& style)
+{
+	source = dest = 0;
+	// masquerading
+	if((port->flags() & streamIn) && (forward->port->flags() & streamIn))
+	{
+		// input: data flow direction is from us to the "forward" port
+		// XXX?
+		source = this;
+		dest = forward;
+		style = VPortConnection::vcMasquerade;
+	}
+	else if((port->flags() & streamOut) && (forward->port->flags() & streamOut))
+	{
+		// output: data flow direction is from the "forward" port to us
+		// XXX?
+		source = forward;
+		dest = this;
+		style = VPortConnection::vcMasquerade;
+	}
+	// forwarding
+	else if((port->flags() & streamIn) && (forward->port->flags() & streamOut))
+	{
+		source = this;
+		dest = forward;
+		style = VPortConnection::vcForward;
+	}
+	else if((port->flags() & streamOut) && (forward->port->flags() & streamIn))
+	{
+		source = forward;
+		dest = this;
+		style = VPortConnection::vcForward;
+	}
+	return source != 0;
+}
+
+/**
+ * a->virtualize(b) means, that the functionality that port a should provide
+ * (e.g. produce or consume data) is really provided by port b
+ */
+void VPort::virtualize(VPort *forward)
+{
+	VPort *source, *dest;
+	VPortConnection::Style style;
+
+	if(makeVirtualizeParams(forward,source,dest,style))
+	{
+#ifdef VPORT_DEBUG
+		cout << "virtualize ... source (producer) is " << source->name() <<
+				" dest (consumer) is " << dest->name() << endl;
+#endif
+		new VPortConnection(source,dest,style);
+	}
+}
+
+void VPort::devirtualize(VPort *forward)
+{
+	VPort *source, *dest;
+	VPortConnection::Style style;
+
+	// XXX?
+	if(makeVirtualizeParams(forward,source,dest,style))
+	{
+		list<VPortConnection *>::iterator i;
+		for(i = source->outgoing.begin(); i != source->outgoing.end(); i++)
+		{
+			if((*i)->source == source && (*i)->dest == dest
+			&& (*i)->style == style)
+			{
+				delete (*i);
+				return;
+			}
+		}
+	}
+}
+
+void VPort::setFloatValue(float value)
+{
+	if(outgoing.empty())
+	{
+		AudioPort *aport = port->audioPort();
+		assert(aport);
+		aport->setFloatValue(value);
+	}
+	else
+	{
+		list<VPortConnection *>::iterator i;
+		for(i=outgoing.begin();i != outgoing.end(); i++)
+		{
+			VPortConnection *conn = *i;
+			assert(conn->style == VPortConnection::vcMasquerade);
+
+			conn->dest->setFloatValue(value);
+		}
+	}
+}
+
+void VPort::connect(VPort *dest)
+{
+	VPortConnection *conn;
+	if(port->flags() & streamOut)
+	{
+		conn = new VPortConnection(this,dest,VPortConnection::vcConnect);
+	}
+	else
+	{
+		conn = new VPortConnection(dest,this,VPortConnection::vcConnect);
+	}
+}
+
+void VPort::disconnect(VPort *dest)
+{
+	if(port->flags() & streamOut)
+	{
+		list<VPortConnection *>::iterator ci = outgoing.begin();
+		while(ci != outgoing.end())
+		{
+			assert((*ci)->source == this);
+			if((*ci)->dest == dest && (*ci)->style==VPortConnection::vcConnect)
+			{
+				delete (*ci);	// will remove itself from the outgoing list
+				return;
+			}
+			ci++;
+		}
+	}
+	else
+	{
+		if(dest->port->flags() & streamOut)
+		{
+			dest->disconnect(this);
+			return;
+		}
+	}
+}
+
+void VPort::expandHelper(VPortConnection *conn, int state, VPort *current,
+									VPort *source, VPort *dest, bool remove)
+{
+	list<VPortConnection *>::iterator ci;
+
+#ifdef VPORT_DEBUG
+	cout << "expandhelper state " << state << " name " << current->name() << endl;
+#endif
+
+	if(state == 1)				/* state 1: scan backward for output ports */
+	{
+		if(current->incoming.empty())
+		{
+			if(current->port->flags() & streamOut)
+				expandHelper(conn,2,current,current,dest,remove);
+		}
+		for(ci = current->incoming.begin(); ci != current->incoming.end();ci++)
+		{
+			assert((*ci)->style != VPortConnection::vcTransport);
+			expandHelper(conn,1,(*ci)->source,source,dest,remove);
+		}
+	}
+	else if(state == 2)			/* state 2: output port expansion */
+	{
+		assert(current->port->flags() & streamOut);
+
+		for(ci = current->outgoing.begin(); ci != current->outgoing.end();ci++)
+		{
+			/* xconn=0 ensures that only paths are counted which contain conn */
+			VPortConnection *xconn = conn;
+			if(*ci == conn) xconn = 0;
+
+			if((*ci)->style == VPortConnection::vcMasquerade)
+			{
+				expandHelper(xconn,2,(*ci)->dest,source,dest,remove);
+			}
+			else if((*ci)->style == VPortConnection::vcConnect)
+			{
+				expandHelper(xconn,3,(*ci)->dest,source,(*ci)->dest,remove);
+			}
+		}
+	}
+	else if(state == 3)			/* state 3: input port expansion */
+	{
+		assert(current->port->flags() & streamIn);
+
+		for(ci = current->outgoing.begin(); ci != current->outgoing.end();ci++)
+		{
+			/* xconn=0 ensures that only paths are counted which contain conn */
+			VPortConnection *xconn = conn;
+			if(*ci == conn) xconn = 0;	
+
+			if((*ci)->style == VPortConnection::vcMasquerade)
+			{
+				// XXX ?
+				expandHelper(xconn,3,(*ci)->dest,source,(*ci)->dest,remove);
+			}
+			else if((*ci)->style == VPortConnection::vcForward)
+			{
+				expandHelper(xconn,2,(*ci)->dest,source,dest,remove);
+			}
+		}
+
+		if(current->outgoing.empty() && conn == 0)
+		{
+			if(remove)
+			{
+				// delete exactly one transport connection
+
+				bool removeOk = false;
+				ci = current->incoming.begin();
+				while(ci != current->incoming.end() && !removeOk)
+				{
+					if((*ci)->source == source && (*ci)->dest == dest
+						&& (*ci)->style == VPortConnection::vcTransport)
+					{
+						delete (*ci);
+						removeOk = true;
+					}
+					else ci++;
+				}
+				assert(removeOk);
+			}
+			else
+			{
+				new VPortConnection(source,dest,VPortConnection::vcTransport);
+			}
+		}
+	}
+}
+
+void VPort::makeTransport(VPortConnection *conn)
+{
+	expandHelper(conn,1,this,0,0,false);
+}
+
+void VPort::removeTransport(VPortConnection *conn)
+{
+	expandHelper(conn,1,this,0,0,true);
+}
+
+const char *VPort::name()
+{
+	if(_name.empty())
+	{
+		_name = port->parent->object()->_interfaceName() + "." +
+				port->name();
+	}
+	return _name.c_str();
+}
diff --git a/flow/virtualports.h b/flow/virtualports.h
new file mode 100644
index 0000000..5e70fbf
--- /dev/null
+++ b/flow/virtualports.h
@@ -0,0 +1,87 @@
+    /*
+
+    Copyright (C) 2000 Stefan Westerfeld
+                       stefan@space.twc.de
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+  
+    This library 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
+    Library General Public License for more details.
+   
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+
+    */
+
+
+#ifndef VIRTUALPORTS_H
+#define VIRTUALPORTS_H
+
+#include "gslschedule.h"
+#include <list>
+
+/*
+ * BC - Status (2002-03-08): VPortConnection, VPort.
+ *
+ * None of these classes is considered part of the public API. Do NOT use it
+ * in your apps. These are part of the implementation of libartsflow's
+ * StdFlowSystem, and subject to change with the needs of it.
+ */
+
+namespace Arts {
+
+class VPortConnection {
+private:
+	friend class VPort;
+	VPort *source;
+	VPort *dest;
+
+public:
+	enum Style { vcForward, vcMasquerade, vcConnect, vcTransport } style;
+	VPortConnection(VPort *source, VPort *dest, Style style);
+	~VPortConnection();
+};
+
+class VPort {
+private:
+	friend class VPortConnection;
+protected:
+	Port *port;
+	std::string _name;
+	std::list<VPortConnection *> incoming, outgoing;
+
+	void makeTransport(VPortConnection *conn);
+	void removeTransport(VPortConnection *conn);
+	void expandHelper(VPortConnection *conn, int state, VPort *current,
+								VPort *source, VPort *dest, bool remove);
+
+	bool makeVirtualizeParams(VPort *forward, VPort *& source, VPort *& dest,
+									VPortConnection::Style &style);
+
+	const char *name();
+public:
+	VPort(Port *p);
+	~VPort();
+
+	void setFloatValue(float value);
+
+	void connect(VPort *vport);
+	void disconnect(VPort *port);
+
+	/**
+	 * a->virtualize(b) means that the functionality that port a should provide
+	 * (produce or consume data) is really provided by port b
+	 */
+	void virtualize(VPort *port);
+	void devirtualize(VPort *port);
+};
+}
+
+#endif /* VIRTUALPORTS_H */