text: /* ------------------------------------------------------------
  author: "Pierre Lecomte"
  copyright: "(c) Pierre Lecomte 2015"
  license: "GPL"
  name: "HOAAzimuthRotator7"
  version: "1.0"
  Code generated with Faust 2.5.21 (https://faust.grame.fr)
  Compilation options: cpp, -double -ftz 0
  ------------------------------------------------------------ */
  
  #ifndef  __mydsp_H__
  #define  __mydsp_H__
  
  //-------------------------------------------------------------------
  // FAUST architecture file for SuperCollider.
  // Copyright (C) 2005-2012 Stefan Kersten.
  //
  // 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
  //-------------------------------------------------------------------
  
  // The prefix is set to "Faust" in the faust2supercollider script, otherwise set empty
  #if !defined(SC_FAUST_PREFIX)
  #define SC_FAUST_PREFIX ""
  #endif
  
  #include <map>
  #include <string>
  #include <string.h>
  #include <SC_PlugIn.h>
  
  /************************************************************************
   FAUST Architecture File
   Copyright (C) 2003-2017 GRAME, Centre National de Creation Musicale
   ---------------------------------------------------------------------
   This Architecture section 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 3 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, see <http://www.gnu.org/licenses/>.
   
   EXCEPTION : As a special exception, you may create a larger work
   that contains this FAUST architecture section and distribute
   that work under terms of your choice, so long as this FAUST
   architecture section is not modified.
   ************************************************************************/
  
  #ifndef __dsp__
  #define __dsp__
  
  #include <string>
  
  #ifndef FAUSTFLOAT
  #define FAUSTFLOAT float
  #endif
  
  class UI;
  struct Meta;
  
  /**
   * DSP memory manager.
   */
  
  struct dsp_memory_manager {
      
      virtual ~dsp_memory_manager() {}
      
      virtual void* allocate(size_t size) = 0;
      virtual void destroy(void* ptr) = 0;
      
  };
  
  /**
  * Signal processor definition.
  */
  
  class dsp {
  
      public:
  
          dsp() {}
          virtual ~dsp() {}
  
          /* Return instance number of audio inputs */
          virtual int getNumInputs() = 0;
      
          /* Return instance number of audio outputs */
          virtual int getNumOutputs() = 0;
      
          /**
           * Trigger the ui_interface parameter with instance specific calls
           * to 'addBtton', 'addVerticalSlider'... in order to build the UI.
           *
           * @param ui_interface - the user interface builder
           */
          virtual void buildUserInterface(UI* ui_interface) = 0;
      
          /* Returns the sample rate currently used by the instance */
          virtual int getSampleRate() = 0;
      
          /**
           * Global init, calls the following methods:
           * - static class 'classInit': static tables initialization
           * - 'instanceInit': constants and instance state initialization
           *
           * @param samplingRate - the sampling rate in Hertz
           */
          virtual void init(int samplingRate) = 0;
  
          /**
           * Init instance state
           *
           * @param samplingRate - the sampling rate in Hertz
           */
          virtual void instanceInit(int samplingRate) = 0;
  
          /**
           * Init instance constant state
           *
           * @param samplingRate - the sampling rate in Hertz
           */
          virtual void instanceConstants(int samplingRate) = 0;
      
          /* Init default control parameters values */
          virtual void instanceResetUserInterface() = 0;
      
          /* Init instance state (delay lines...) */
          virtual void instanceClear() = 0;
   
          /**
           * Return a clone of the instance.
           *
           * @return a copy of the instance on success, otherwise a null pointer.
           */
          virtual dsp* clone() = 0;
      
          /**
           * Trigger the Meta* parameter with instance specific calls to 'declare' (key, value) metadata.
           *
           * @param m - the Meta* meta user
           */
          virtual void metadata(Meta* m) = 0;
      
          /**
           * DSP instance computation, to be called with successive in/out audio buffers.
           *
           * @param count - the number of frames to compute
           * @param inputs - the input audio buffers as an array of non-interleaved FAUSTFLOAT samples (eiher float, double or quad)
           * @param outputs - the output audio buffers as an array of non-interleaved FAUSTFLOAT samples (eiher float, double or quad)
           *
           */
          virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) = 0;
      
          /**
           * DSP instance computation: alternative method to be used by subclasses.
           *
           * @param date_usec - the timestamp in microsec given by audio driver.
           * @param count - the number of frames to compute
           * @param inputs - the input audio buffers as an array of non-interleaved FAUSTFLOAT samples (eiher float, double or quad)
           * @param outputs - the output audio buffers as an array of non-interleaved FAUSTFLOAT samples (eiher float, double or quad)
           *
           */
          virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { compute(count, inputs, outputs); }
         
  };
  
  /**
   * Generic DSP decorator.
   */
  
  class decorator_dsp : public dsp {
  
      protected:
  
          dsp* fDSP;
  
      public:
  
          decorator_dsp(dsp* dsp = 0):fDSP(dsp) {}
          virtual ~decorator_dsp() { delete fDSP; }
  
          virtual int getNumInputs() { return fDSP->getNumInputs(); }
          virtual int getNumOutputs() { return fDSP->getNumOutputs(); }
          virtual void buildUserInterface(UI* ui_interface) { fDSP->buildUserInterface(ui_interface); }
          virtual int getSampleRate() { return fDSP->getSampleRate(); }
          virtual void init(int samplingRate) { fDSP->init(samplingRate); }
          virtual void instanceInit(int samplingRate) { fDSP->instanceInit(samplingRate); }
          virtual void instanceConstants(int samplingRate) { fDSP->instanceConstants(samplingRate); }
          virtual void instanceResetUserInterface() { fDSP->instanceResetUserInterface(); }
          virtual void instanceClear() { fDSP->instanceClear(); }
          virtual decorator_dsp* clone() { return new decorator_dsp(fDSP->clone()); }
          virtual void metadata(Meta* m) { fDSP->metadata(m); }
          // Beware: subclasses usually have to overload the two 'compute' methods
          virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { fDSP->compute(count, inputs, outputs); }
          virtual void compute(double date_usec, int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) { fDSP->compute(date_usec, count, inputs, outputs); }
      
  };
  
  /**
   * DSP factory class.
   */
  
  class dsp_factory {
      
      protected:
      
          // So that to force sub-classes to use deleteDSPFactory(dsp_factory* factory);
          virtual ~dsp_factory() {}
      
      public:
      
          virtual std::string getName() = 0;
          virtual std::string getSHAKey() = 0;
          virtual std::string getDSPCode() = 0;
      
          virtual dsp* createDSPInstance() = 0;
      
          virtual void setMemoryManager(dsp_memory_manager* manager) = 0;
          virtual dsp_memory_manager* getMemoryManager() = 0;
      
  };
  
  /**
   * On Intel set FZ (Flush to Zero) and DAZ (Denormals Are Zero)
   * flags to avoid costly denormals.
   */
  
  #ifdef __SSE__
      #include <xmmintrin.h>
      #ifdef __SSE2__
          #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8040)
      #else
          #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8000)
      #endif
  #else
      #define AVOIDDENORMALS
  #endif
  
  #endif
  /************************************************************************
   FAUST Architecture File
   Copyright (C) 2003-2017 GRAME, Centre National de Creation Musicale
   ---------------------------------------------------------------------
   This Architecture section 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 3 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, see <http://www.gnu.org/licenses/>.
   
   EXCEPTION : As a special exception, you may create a larger work
   that contains this FAUST architecture section and distribute
   that work under terms of your choice, so long as this FAUST
   architecture section is not modified.
   ************************************************************************/
  
  #ifndef __UI_H__
  #define __UI_H__
  
  #ifndef FAUSTFLOAT
  #define FAUSTFLOAT float
  #endif
  
  /*******************************************************************************
   * UI : Faust DSP User Interface
   * User Interface as expected by the buildUserInterface() method of a DSP.
   * This abstract class contains only the method that the Faust compiler can
   * generate to describe a DSP user interface.
   ******************************************************************************/
  
  struct Soundfile;
  
  class UI
  {
  
      public:
  
          UI() {}
  
          virtual ~UI() {}
  
          // -- widget's layouts
  
          virtual void openTabBox(const char* label) = 0;
          virtual void openHorizontalBox(const char* label) = 0;
          virtual void openVerticalBox(const char* label) = 0;
          virtual void closeBox() = 0;
  
          // -- active widgets
  
          virtual void addButton(const char* label, FAUSTFLOAT* zone) = 0;
          virtual void addCheckButton(const char* label, FAUSTFLOAT* zone) = 0;
          virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) = 0;
          virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) = 0;
          virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step) = 0;
  
          // -- passive widgets
  
          virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) = 0;
          virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) = 0;
      
          // -- soundfiles
      
          virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) = 0;
  
          // -- metadata declarations
  
          virtual void declare(FAUSTFLOAT*, const char*, const char*) {}
  };
  
  #endif
  /************************************************************************
   FAUST Architecture File
   Copyright (C) 2003-2017 GRAME, Centre National de Creation Musicale
   ---------------------------------------------------------------------
   This Architecture section 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 3 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, see <http://www.gnu.org/licenses/>.
   
   EXCEPTION : As a special exception, you may create a larger work
   that contains this FAUST architecture section and distribute
   that work under terms of your choice, so long as this FAUST
   architecture section is not modified.
   ************************************************************************/
   
  #ifndef __misc__
  #define __misc__
  
  #include <algorithm>
  #include <map>
  #include <string.h>
  #include <stdlib.h>
  
  /************************************************************************
   FAUST Architecture File
   Copyright (C) 2003-2017 GRAME, Centre National de Creation Musicale
   ---------------------------------------------------------------------
   This Architecture section 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 3 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, see <http://www.gnu.org/licenses/>.
   
   EXCEPTION : As a special exception, you may create a larger work
   that contains this FAUST architecture section and distribute
   that work under terms of your choice, so long as this FAUST
   architecture section is not modified.
   ************************************************************************/
  
  #ifndef __meta__
  #define __meta__
  
  struct Meta
  {
      virtual void declare(const char* key, const char* value) = 0;
      virtual ~Meta() {};
  };
  
  #endif
  
  using std::max;
  using std::min;
  
  struct XXXX_Meta : std::map<const char*, const char*>
  {
      void declare(const char* key, const char* value) { (*this)[key]=value; }
  };
  
  struct MY_Meta : Meta, std::map<const char*, const char*>
  {
      void declare(const char* key, const char* value) { (*this)[key]=value; }
  };
  
  inline int lsr(int x, int n)	{ return int(((unsigned int)x) >> n); }
  
  inline int int2pow2(int x)		{ int r = 0; while ((1<<r) < x) r++; return r; }
  
  inline long lopt(char* argv[], const char* name, long def)
  {
  	int	i;
  	for (i = 0; argv[i]; i++) if (!strcmp(argv[i], name)) return atoi(argv[i+1]);
  	return def;
  }
  
  inline bool isopt(char* argv[], const char* name)
  {
  	int	i;
  	for (i = 0; argv[i]; i++) if (!strcmp(argv[i], name)) return true;
  	return false;
  }
  
  inline const char* lopts(char* argv[], const char* name, const char* def)
  {
  	int	i;
  	for (i = 0; argv[i]; i++) if (!strcmp(argv[i], name)) return argv[i+1];
  	return def;
  }
  
  #endif
  
  
  using namespace std;
  
  #if defined(__GNUC__) && __GNUC__ >= 4
      #define FAUST_EXPORT __attribute__((visibility("default")))
  #else
      #define FAUST_EXPORT  SC_API_EXPORT
  #endif
  
  #ifdef WIN32
      #define STRDUP _strdup
  #else
      #define STRDUP strdup
  #endif
  
  //----------------------------------------------------------------------------
  // Vector intrinsics
  //----------------------------------------------------------------------------
  
  
  //----------------------------------------------------------------------------
  // Metadata
  //----------------------------------------------------------------------------
  
  class MetaData : public Meta
                 , public std::map<std::string, std::string>
  {
  public:
      void declare(const char* key, const char* value)
      {
          (*this)[key] = value;
      }
  };
  
  //----------------------------------------------------------------------------
  // Control counter
  //----------------------------------------------------------------------------
  
  class ControlCounter : public UI
  {
  public:
      ControlCounter()
          : mNumControlInputs(0),
            mNumControlOutputs(0)
      {}
  
      size_t getNumControls() const { return getNumControlInputs(); }
      size_t getNumControlInputs() const { return mNumControlInputs; }
      size_t getNumControlOutputs() const { return mNumControlOutputs; }
  
      // Layout widgets
      virtual void openTabBox(const char* label) { }
      virtual void openHorizontalBox(const char* label) { }
      virtual void openVerticalBox(const char* label) { }
      virtual void closeBox() { }
  
      // Active widgets
      virtual void addButton(const char* label, FAUSTFLOAT* zone)
      { addControlInput(); }
      virtual void addCheckButton(const char* label, FAUSTFLOAT* zone)
      { addControlInput(); }
      virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
      { addControlInput(); }
      virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
      { addControlInput(); }
      virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
      { addControlInput(); }
  
      // Passive widgets
      virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
      { addControlOutput(); }
      virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
      { addControlOutput(); }
      
      virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
  
  protected:
      void addControlInput() { mNumControlInputs++; }
      void addControlOutput() { mNumControlOutputs++; }
  
  private:
      size_t mNumControlInputs;
      size_t mNumControlOutputs;
  };
  
  //----------------------------------------------------------------------------
  // UI control
  //----------------------------------------------------------------------------
  
  struct Control
  {
      typedef void (*UpdateFunction)(Control* self, FAUSTFLOAT value);
  
      UpdateFunction updateFunction;
      FAUSTFLOAT* zone;
      FAUSTFLOAT min, max;
  
      inline void update(FAUSTFLOAT value)
      {
          (*updateFunction)(this, value);
      }
  
      static void simpleUpdate(Control* self, FAUSTFLOAT value)
      {
          *self->zone = value;
      }
      static void boundedUpdate(Control* self, FAUSTFLOAT value)
      {
          *self->zone = sc_clip(value, self->min, self->max);
      }
  };
  
  //----------------------------------------------------------------------------
  // Control allocator
  //----------------------------------------------------------------------------
  
  class ControlAllocator : public UI
  {
  public:
      ControlAllocator(Control* controls)
          : mControls(controls)
      { }
  
      // Layout widgets
      virtual void openTabBox(const char* label) { }
      virtual void openHorizontalBox(const char* label) { }
      virtual void openVerticalBox(const char* label) { }
      virtual void closeBox() { }
  
      // Active widgets
      virtual void addButton(const char* label, FAUSTFLOAT* zone)
      { addSimpleControl(zone); }
      virtual void addCheckButton(const char* label, FAUSTFLOAT* zone)
      { addSimpleControl(zone); }
      virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
      { addBoundedControl(zone, min, max, step); }
      virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
      { addBoundedControl(zone, min, max, step); }
      virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
      { addBoundedControl(zone, min, max, step); }
  
      // Passive widgets
      virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) {}
      virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max) {}
      virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
  
  private:
      void addControl(Control::UpdateFunction updateFunction, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT /* step */)
      {
          Control* ctrl        = mControls++;
          ctrl->updateFunction = updateFunction;
          ctrl->zone           = zone;
          ctrl->min            = min;
          ctrl->max            = max;
      }
      void addSimpleControl(FAUSTFLOAT* zone)
      {
          addControl(Control::simpleUpdate, zone, 0.f, 0.f, 0.f);
      }
      void addBoundedControl(FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
      {
          addControl(Control::boundedUpdate, zone, min, max, step);
      }
  
  private:
      Control* mControls;
  };
  
  //----------------------------------------------------------------------------
  // FAUST generated code
  //----------------------------------------------------------------------------
  
  #ifndef FAUSTFLOAT
  #define FAUSTFLOAT float
  #endif 
  
  #include <cmath>
  
  
  #ifndef FAUSTCLASS 
  #define FAUSTCLASS mydsp
  #endif
  #ifdef __APPLE__ 
  #define exp10f __exp10f
  #define exp10 __exp10
  #endif
  
  class mydsp : public dsp {
  	
   private:
  	
  	FAUSTFLOAT fHslider0;
  	int fSamplingFreq;
  	
   public:
  	
  	void metadata(Meta* m) { 
  		m->declare("author", "Pierre Lecomte");
  		m->declare("basics.lib/name", "Faust Basic Element Library");
  		m->declare("basics.lib/version", "0.0");
  		m->declare("copyright", "(c) Pierre Lecomte 2015");
  		m->declare("license", "GPL");
  		m->declare("maths.lib/author", "GRAME");
  		m->declare("maths.lib/copyright", "GRAME");
  		m->declare("maths.lib/license", "LGPL with exception");
  		m->declare("maths.lib/name", "Faust Math Library");
  		m->declare("maths.lib/version", "2.1");
  		m->declare("name", "HOAAzimuthRotator7");
  		m->declare("version", "1.0");
  		m->declare("ymn.lib/author", "Pierre Lecomte");
  		m->declare("ymn.lib/copyright", "(c) Pierre Lecomte 2017");
  		m->declare("ymn.lib/license", "GPL");
  		m->declare("ymn.lib/name", "Spherical Harmonics library");
  		m->declare("ymn.lib/version", "2.0");
  	}
  
  	virtual int getNumInputs() {
  		return 64;
  		
  	}
  	virtual int getNumOutputs() {
  		return 64;
  		
  	}
  	virtual int getInputRate(int channel) {
  		int rate;
  		switch (channel) {
  			case 0: {
  				rate = 1;
  				break;
  			}
  			case 1: {
  				rate = 1;
  				break;
  			}
  			case 2: {
  				rate = 1;
  				break;
  			}
  			case 3: {
  				rate = 1;
  				break;
  			}
  			case 4: {
  				rate = 1;
  				break;
  			}
  			case 5: {
  				rate = 1;
  				break;
  			}
  			case 6: {
  				rate = 1;
  				break;
  			}
  			case 7: {
  				rate = 1;
  				break;
  			}
  			case 8: {
  				rate = 1;
  				break;
  			}
  			case 9: {
  				rate = 1;
  				break;
  			}
  			case 10: {
  				rate = 1;
  				break;
  			}
  			case 11: {
  				rate = 1;
  				break;
  			}
  			case 12: {
  				rate = 1;
  				break;
  			}
  			case 13: {
  				rate = 1;
  				break;
  			}
  			case 14: {
  				rate = 1;
  				break;
  			}
  			case 15: {
  				rate = 1;
  				break;
  			}
  			case 16: {
  				rate = 1;
  				break;
  			}
  			case 17: {
  				rate = 1;
  				break;
  			}
  			case 18: {
  				rate = 1;
  				break;
  			}
  			case 19: {
  				rate = 1;
  				break;
  			}
  			case 20: {
  				rate = 1;
  				break;
  			}
  			case 21: {
  				rate = 1;
  				break;
  			}
  			case 22: {
  				rate = 1;
  				break;
  			}
  			case 23: {
  				rate = 1;
  				break;
  			}
  			case 24: {
  				rate = 1;
  				break;
  			}
  			case 25: {
  				rate = 1;
  				break;
  			}
  			case 26: {
  				rate = 1;
  				break;
  			}
  			case 27: {
  				rate = 1;
  				break;
  			}
  			case 28: {
  				rate = 1;
  				break;
  			}
  			case 29: {
  				rate = 1;
  				break;
  			}
  			case 30: {
  				rate = 1;
  				break;
  			}
  			case 31: {
  				rate = 1;
  				break;
  			}
  			case 32: {
  				rate = 1;
  				break;
  			}
  			case 33: {
  				rate = 1;
  				break;
  			}
  			case 34: {
  				rate = 1;
  				break;
  			}
  			case 35: {
  				rate = 1;
  				break;
  			}
  			case 36: {
  				rate = 1;
  				break;
  			}
  			case 37: {
  				rate = 1;
  				break;
  			}
  			case 38: {
  				rate = 1;
  				break;
  			}
  			case 39: {
  				rate = 1;
  				break;
  			}
  			case 40: {
  				rate = 1;
  				break;
  			}
  			case 41: {
  				rate = 1;
  				break;
  			}
  			case 42: {
  				rate = 1;
  				break;
  			}
  			case 43: {
  				rate = 1;
  				break;
  			}
  			case 44: {
  				rate = 1;
  				break;
  			}
  			case 45: {
  				rate = 1;
  				break;
  			}
  			case 46: {
  				rate = 1;
  				break;
  			}
  			case 47: {
  				rate = 1;
  				break;
  			}
  			case 48: {
  				rate = 1;
  				break;
  			}
  			case 49: {
  				rate = 1;
  				break;
  			}
  			case 50: {
  				rate = 1;
  				break;
  			}
  			case 51: {
  				rate = 1;
  				break;
  			}
  			case 52: {
  				rate = 1;
  				break;
  			}
  			case 53: {
  				rate = 1;
  				break;
  			}
  			case 54: {
  				rate = 1;
  				break;
  			}
  			case 55: {
  				rate = 1;
  				break;
  			}
  			case 56: {
  				rate = 1;
  				break;
  			}
  			case 57: {
  				rate = 1;
  				break;
  			}
  			case 58: {
  				rate = 1;
  				break;
  			}
  			case 59: {
  				rate = 1;
  				break;
  			}
  			case 60: {
  				rate = 1;
  				break;
  			}
  			case 61: {
  				rate = 1;
  				break;
  			}
  			case 62: {
  				rate = 1;
  				break;
  			}
  			case 63: {
  				rate = 1;
  				break;
  			}
  			default: {
  				rate = -1;
  				break;
  			}
  			
  		}
  		return rate;
  		
  	}
  	virtual int getOutputRate(int channel) {
  		int rate;
  		switch (channel) {
  			case 0: {
  				rate = 1;
  				break;
  			}
  			case 1: {
  				rate = 1;
  				break;
  			}
  			case 2: {
  				rate = 1;
  				break;
  			}
  			case 3: {
  				rate = 1;
  				break;
  			}
  			case 4: {
  				rate = 1;
  				break;
  			}
  			case 5: {
  				rate = 1;
  				break;
  			}
  			case 6: {
  				rate = 1;
  				break;
  			}
  			case 7: {
  				rate = 1;
  				break;
  			}
  			case 8: {
  				rate = 1;
  				break;
  			}
  			case 9: {
  				rate = 1;
  				break;
  			}
  			case 10: {
  				rate = 1;
  				break;
  			}
  			case 11: {
  				rate = 1;
  				break;
  			}
  			case 12: {
  				rate = 1;
  				break;
  			}
  			case 13: {
  				rate = 1;
  				break;
  			}
  			case 14: {
  				rate = 1;
  				break;
  			}
  			case 15: {
  				rate = 1;
  				break;
  			}
  			case 16: {
  				rate = 1;
  				break;
  			}
  			case 17: {
  				rate = 1;
  				break;
  			}
  			case 18: {
  				rate = 1;
  				break;
  			}
  			case 19: {
  				rate = 1;
  				break;
  			}
  			case 20: {
  				rate = 1;
  				break;
  			}
  			case 21: {
  				rate = 1;
  				break;
  			}
  			case 22: {
  				rate = 1;
  				break;
  			}
  			case 23: {
  				rate = 1;
  				break;
  			}
  			case 24: {
  				rate = 1;
  				break;
  			}
  			case 25: {
  				rate = 1;
  				break;
  			}
  			case 26: {
  				rate = 1;
  				break;
  			}
  			case 27: {
  				rate = 1;
  				break;
  			}
  			case 28: {
  				rate = 1;
  				break;
  			}
  			case 29: {
  				rate = 1;
  				break;
  			}
  			case 30: {
  				rate = 1;
  				break;
  			}
  			case 31: {
  				rate = 1;
  				break;
  			}
  			case 32: {
  				rate = 1;
  				break;
  			}
  			case 33: {
  				rate = 1;
  				break;
  			}
  			case 34: {
  				rate = 1;
  				break;
  			}
  			case 35: {
  				rate = 1;
  				break;
  			}
  			case 36: {
  				rate = 1;
  				break;
  			}
  			case 37: {
  				rate = 1;
  				break;
  			}
  			case 38: {
  				rate = 1;
  				break;
  			}
  			case 39: {
  				rate = 1;
  				break;
  			}
  			case 40: {
  				rate = 1;
  				break;
  			}
  			case 41: {
  				rate = 1;
  				break;
  			}
  			case 42: {
  				rate = 1;
  				break;
  			}
  			case 43: {
  				rate = 1;
  				break;
  			}
  			case 44: {
  				rate = 1;
  				break;
  			}
  			case 45: {
  				rate = 1;
  				break;
  			}
  			case 46: {
  				rate = 1;
  				break;
  			}
  			case 47: {
  				rate = 1;
  				break;
  			}
  			case 48: {
  				rate = 1;
  				break;
  			}
  			case 49: {
  				rate = 1;
  				break;
  			}
  			case 50: {
  				rate = 1;
  				break;
  			}
  			case 51: {
  				rate = 1;
  				break;
  			}
  			case 52: {
  				rate = 1;
  				break;
  			}
  			case 53: {
  				rate = 1;
  				break;
  			}
  			case 54: {
  				rate = 1;
  				break;
  			}
  			case 55: {
  				rate = 1;
  				break;
  			}
  			case 56: {
  				rate = 1;
  				break;
  			}
  			case 57: {
  				rate = 1;
  				break;
  			}
  			case 58: {
  				rate = 1;
  				break;
  			}
  			case 59: {
  				rate = 1;
  				break;
  			}
  			case 60: {
  				rate = 1;
  				break;
  			}
  			case 61: {
  				rate = 1;
  				break;
  			}
  			case 62: {
  				rate = 1;
  				break;
  			}
  			case 63: {
  				rate = 1;
  				break;
  			}
  			default: {
  				rate = -1;
  				break;
  			}
  			
  		}
  		return rate;
  		
  	}
  	
  	static void classInit(int samplingFreq) {
  		
  	}
  	
  	virtual void instanceConstants(int samplingFreq) {
  		fSamplingFreq = samplingFreq;
  		
  	}
  	
  	virtual void instanceResetUserInterface() {
  		fHslider0 = FAUSTFLOAT(0.0);
  		
  	}
  	
  	virtual void instanceClear() {
  		
  	}
  	
  	virtual void init(int samplingFreq) {
  		classInit(samplingFreq);
  		instanceInit(samplingFreq);
  	}
  	virtual void instanceInit(int samplingFreq) {
  		instanceConstants(samplingFreq);
  		instanceResetUserInterface();
  		instanceClear();
  	}
  	
  	virtual mydsp* clone() {
  		return new mydsp();
  	}
  	virtual int getSampleRate() {
  		return fSamplingFreq;
  		
  	}
  	
  	virtual void buildUserInterface(UI* ui_interface) {
  		ui_interface->openVerticalBox("HOAAzimuthRotator7");
  		ui_interface->declare(&fHslider0, "osc", "/azimuth 0 360");
  		ui_interface->addHorizontalSlider("Azimuth", &fHslider0, 0.0, -3.1415926535897931, 3.1415926535897931, 0.01);
  		ui_interface->closeBox();
  		
  	}
  	
  	virtual void compute(int count, FAUSTFLOAT** inputs, FAUSTFLOAT** outputs) {
  		FAUSTFLOAT* input0 = inputs[0];
  		FAUSTFLOAT* input1 = inputs[1];
  		FAUSTFLOAT* input2 = inputs[2];
  		FAUSTFLOAT* input3 = inputs[3];
  		FAUSTFLOAT* input4 = inputs[4];
  		FAUSTFLOAT* input5 = inputs[5];
  		FAUSTFLOAT* input6 = inputs[6];
  		FAUSTFLOAT* input7 = inputs[7];
  		FAUSTFLOAT* input8 = inputs[8];
  		FAUSTFLOAT* input9 = inputs[9];
  		FAUSTFLOAT* input10 = inputs[10];
  		FAUSTFLOAT* input11 = inputs[11];
  		FAUSTFLOAT* input12 = inputs[12];
  		FAUSTFLOAT* input13 = inputs[13];
  		FAUSTFLOAT* input14 = inputs[14];
  		FAUSTFLOAT* input15 = inputs[15];
  		FAUSTFLOAT* input16 = inputs[16];
  		FAUSTFLOAT* input17 = inputs[17];
  		FAUSTFLOAT* input18 = inputs[18];
  		FAUSTFLOAT* input19 = inputs[19];
  		FAUSTFLOAT* input20 = inputs[20];
  		FAUSTFLOAT* input21 = inputs[21];
  		FAUSTFLOAT* input22 = inputs[22];
  		FAUSTFLOAT* input23 = inputs[23];
  		FAUSTFLOAT* input24 = inputs[24];
  		FAUSTFLOAT* input25 = inputs[25];
  		FAUSTFLOAT* input26 = inputs[26];
  		FAUSTFLOAT* input27 = inputs[27];
  		FAUSTFLOAT* input28 = inputs[28];
  		FAUSTFLOAT* input29 = inputs[29];
  		FAUSTFLOAT* input30 = inputs[30];
  		FAUSTFLOAT* input31 = inputs[31];
  		FAUSTFLOAT* input32 = inputs[32];
  		FAUSTFLOAT* input33 = inputs[33];
  		FAUSTFLOAT* input34 = inputs[34];
  		FAUSTFLOAT* input35 = inputs[35];
  		FAUSTFLOAT* input36 = inputs[36];
  		FAUSTFLOAT* input37 = inputs[37];
  		FAUSTFLOAT* input38 = inputs[38];
  		FAUSTFLOAT* input39 = inputs[39];
  		FAUSTFLOAT* input40 = inputs[40];
  		FAUSTFLOAT* input41 = inputs[41];
  		FAUSTFLOAT* input42 = inputs[42];
  		FAUSTFLOAT* input43 = inputs[43];
  		FAUSTFLOAT* input44 = inputs[44];
  		FAUSTFLOAT* input45 = inputs[45];
  		FAUSTFLOAT* input46 = inputs[46];
  		FAUSTFLOAT* input47 = inputs[47];
  		FAUSTFLOAT* input48 = inputs[48];
  		FAUSTFLOAT* input49 = inputs[49];
  		FAUSTFLOAT* input50 = inputs[50];
  		FAUSTFLOAT* input51 = inputs[51];
  		FAUSTFLOAT* input52 = inputs[52];
  		FAUSTFLOAT* input53 = inputs[53];
  		FAUSTFLOAT* input54 = inputs[54];
  		FAUSTFLOAT* input55 = inputs[55];
  		FAUSTFLOAT* input56 = inputs[56];
  		FAUSTFLOAT* input57 = inputs[57];
  		FAUSTFLOAT* input58 = inputs[58];
  		FAUSTFLOAT* input59 = inputs[59];
  		FAUSTFLOAT* input60 = inputs[60];
  		FAUSTFLOAT* input61 = inputs[61];
  		FAUSTFLOAT* input62 = inputs[62];
  		FAUSTFLOAT* input63 = inputs[63];
  		FAUSTFLOAT* output0 = outputs[0];
  		FAUSTFLOAT* output1 = outputs[1];
  		FAUSTFLOAT* output2 = outputs[2];
  		FAUSTFLOAT* output3 = outputs[3];
  		FAUSTFLOAT* output4 = outputs[4];
  		FAUSTFLOAT* output5 = outputs[5];
  		FAUSTFLOAT* output6 = outputs[6];
  		FAUSTFLOAT* output7 = outputs[7];
  		FAUSTFLOAT* output8 = outputs[8];
  		FAUSTFLOAT* output9 = outputs[9];
  		FAUSTFLOAT* output10 = outputs[10];
  		FAUSTFLOAT* output11 = outputs[11];
  		FAUSTFLOAT* output12 = outputs[12];
  		FAUSTFLOAT* output13 = outputs[13];
  		FAUSTFLOAT* output14 = outputs[14];
  		FAUSTFLOAT* output15 = outputs[15];
  		FAUSTFLOAT* output16 = outputs[16];
  		FAUSTFLOAT* output17 = outputs[17];
  		FAUSTFLOAT* output18 = outputs[18];
  		FAUSTFLOAT* output19 = outputs[19];
  		FAUSTFLOAT* output20 = outputs[20];
  		FAUSTFLOAT* output21 = outputs[21];
  		FAUSTFLOAT* output22 = outputs[22];
  		FAUSTFLOAT* output23 = outputs[23];
  		FAUSTFLOAT* output24 = outputs[24];
  		FAUSTFLOAT* output25 = outputs[25];
  		FAUSTFLOAT* output26 = outputs[26];
  		FAUSTFLOAT* output27 = outputs[27];
  		FAUSTFLOAT* output28 = outputs[28];
  		FAUSTFLOAT* output29 = outputs[29];
  		FAUSTFLOAT* output30 = outputs[30];
  		FAUSTFLOAT* output31 = outputs[31];
  		FAUSTFLOAT* output32 = outputs[32];
  		FAUSTFLOAT* output33 = outputs[33];
  		FAUSTFLOAT* output34 = outputs[34];
  		FAUSTFLOAT* output35 = outputs[35];
  		FAUSTFLOAT* output36 = outputs[36];
  		FAUSTFLOAT* output37 = outputs[37];
  		FAUSTFLOAT* output38 = outputs[38];
  		FAUSTFLOAT* output39 = outputs[39];
  		FAUSTFLOAT* output40 = outputs[40];
  		FAUSTFLOAT* output41 = outputs[41];
  		FAUSTFLOAT* output42 = outputs[42];
  		FAUSTFLOAT* output43 = outputs[43];
  		FAUSTFLOAT* output44 = outputs[44];
  		FAUSTFLOAT* output45 = outputs[45];
  		FAUSTFLOAT* output46 = outputs[46];
  		FAUSTFLOAT* output47 = outputs[47];
  		FAUSTFLOAT* output48 = outputs[48];
  		FAUSTFLOAT* output49 = outputs[49];
  		FAUSTFLOAT* output50 = outputs[50];
  		FAUSTFLOAT* output51 = outputs[51];
  		FAUSTFLOAT* output52 = outputs[52];
  		FAUSTFLOAT* output53 = outputs[53];
  		FAUSTFLOAT* output54 = outputs[54];
  		FAUSTFLOAT* output55 = outputs[55];
  		FAUSTFLOAT* output56 = outputs[56];
  		FAUSTFLOAT* output57 = outputs[57];
  		FAUSTFLOAT* output58 = outputs[58];
  		FAUSTFLOAT* output59 = outputs[59];
  		FAUSTFLOAT* output60 = outputs[60];
  		FAUSTFLOAT* output61 = outputs[61];
  		FAUSTFLOAT* output62 = outputs[62];
  		FAUSTFLOAT* output63 = outputs[63];
  		double fSlow0 = double(fHslider0);
  		double fSlow1 = cos(fSlow0);
  		double fSlow2 = sin(fSlow0);
  		double fSlow3 = (0.0 - fSlow0);
  		double fSlow4 = sin(fSlow3);
  		double fSlow5 = cos(fSlow3);
  		double fSlow6 = (2.0 * fSlow0);
  		double fSlow7 = cos(fSlow6);
  		double fSlow8 = sin(fSlow6);
  		double fSlow9 = (0.0 - fSlow6);
  		double fSlow10 = sin(fSlow9);
  		double fSlow11 = cos(fSlow9);
  		double fSlow12 = (3.0 * fSlow0);
  		double fSlow13 = cos(fSlow12);
  		double fSlow14 = sin(fSlow12);
  		double fSlow15 = (0.0 - fSlow12);
  		double fSlow16 = sin(fSlow15);
  		double fSlow17 = cos(fSlow15);
  		double fSlow18 = (4.0 * fSlow0);
  		double fSlow19 = cos(fSlow18);
  		double fSlow20 = sin(fSlow18);
  		double fSlow21 = (0.0 - fSlow18);
  		double fSlow22 = sin(fSlow21);
  		double fSlow23 = cos(fSlow21);
  		double fSlow24 = (5.0 * fSlow0);
  		double fSlow25 = cos(fSlow24);
  		double fSlow26 = sin(fSlow24);
  		double fSlow27 = (0.0 - fSlow24);
  		double fSlow28 = sin(fSlow27);
  		double fSlow29 = cos(fSlow27);
  		double fSlow30 = (6.0 * fSlow0);
  		double fSlow31 = cos(fSlow30);
  		double fSlow32 = sin(fSlow30);
  		double fSlow33 = (0.0 - fSlow30);
  		double fSlow34 = sin(fSlow33);
  		double fSlow35 = cos(fSlow33);
  		double fSlow36 = (7.0 * fSlow0);
  		double fSlow37 = cos(fSlow36);
  		double fSlow38 = sin(fSlow36);
  		double fSlow39 = (0.0 - fSlow36);
  		double fSlow40 = sin(fSlow39);
  		double fSlow41 = cos(fSlow39);
  		for (int i = 0; (i < count); i = (i + 1)) {
  			output0[i] = FAUSTFLOAT(double(input0[i]));
  			double fTemp0 = double(input1[i]);
  			double fTemp1 = double(input3[i]);
  			output1[i] = FAUSTFLOAT(((fSlow1 * fTemp0) + (fSlow2 * fTemp1)));
  			output2[i] = FAUSTFLOAT(double(input2[i]));
  			output3[i] = FAUSTFLOAT(((fSlow4 * fTemp0) + (fSlow5 * fTemp1)));
  			double fTemp2 = double(input4[i]);
  			double fTemp3 = double(input8[i]);
  			output4[i] = FAUSTFLOAT(((fSlow7 * fTemp2) + (fSlow8 * fTemp3)));
  			double fTemp4 = double(input5[i]);
  			double fTemp5 = double(input7[i]);
  			output5[i] = FAUSTFLOAT(((fSlow1 * fTemp4) + (fSlow2 * fTemp5)));
  			output6[i] = FAUSTFLOAT(double(input6[i]));
  			output7[i] = FAUSTFLOAT(((fSlow4 * fTemp4) + (fSlow5 * fTemp5)));
  			output8[i] = FAUSTFLOAT(((fSlow10 * fTemp2) + (fSlow11 * fTemp3)));
  			double fTemp6 = double(input9[i]);
  			double fTemp7 = double(input15[i]);
  			output9[i] = FAUSTFLOAT(((fSlow13 * fTemp6) + (fSlow14 * fTemp7)));
  			double fTemp8 = double(input10[i]);
  			double fTemp9 = double(input14[i]);
  			output10[i] = FAUSTFLOAT(((fSlow7 * fTemp8) + (fSlow8 * fTemp9)));
  			double fTemp10 = double(input11[i]);
  			double fTemp11 = double(input13[i]);
  			output11[i] = FAUSTFLOAT(((fSlow1 * fTemp10) + (fSlow2 * fTemp11)));
  			output12[i] = FAUSTFLOAT(double(input12[i]));
  			output13[i] = FAUSTFLOAT(((fSlow4 * fTemp10) + (fSlow5 * fTemp11)));
  			output14[i] = FAUSTFLOAT(((fSlow10 * fTemp8) + (fSlow11 * fTemp9)));
  			output15[i] = FAUSTFLOAT(((fSlow16 * fTemp6) + (fSlow17 * fTemp7)));
  			double fTemp12 = double(input16[i]);
  			double fTemp13 = double(input24[i]);
  			output16[i] = FAUSTFLOAT(((fSlow19 * fTemp12) + (fSlow20 * fTemp13)));
  			double fTemp14 = double(input17[i]);
  			double fTemp15 = double(input23[i]);
  			output17[i] = FAUSTFLOAT(((fSlow13 * fTemp14) + (fSlow14 * fTemp15)));
  			double fTemp16 = double(input18[i]);
  			double fTemp17 = double(input22[i]);
  			output18[i] = FAUSTFLOAT(((fSlow7 * fTemp16) + (fSlow8 * fTemp17)));
  			double fTemp18 = double(input19[i]);
  			double fTemp19 = double(input21[i]);
  			output19[i] = FAUSTFLOAT(((fSlow1 * fTemp18) + (fSlow2 * fTemp19)));
  			output20[i] = FAUSTFLOAT(double(input20[i]));
  			output21[i] = FAUSTFLOAT(((fSlow4 * fTemp18) + (fSlow5 * fTemp19)));
  			output22[i] = FAUSTFLOAT(((fSlow10 * fTemp16) + (fSlow11 * fTemp17)));
  			output23[i] = FAUSTFLOAT(((fSlow16 * fTemp14) + (fSlow17 * fTemp15)));
  			output24[i] = FAUSTFLOAT(((fSlow22 * fTemp12) + (fSlow23 * fTemp13)));
  			double fTemp20 = double(input25[i]);
  			double fTemp21 = double(input35[i]);
  			output25[i] = FAUSTFLOAT(((fSlow25 * fTemp20) + (fSlow26 * fTemp21)));
  			double fTemp22 = double(input26[i]);
  			double fTemp23 = double(input34[i]);
  			output26[i] = FAUSTFLOAT(((fSlow19 * fTemp22) + (fSlow20 * fTemp23)));
  			double fTemp24 = double(input27[i]);
  			double fTemp25 = double(input33[i]);
  			output27[i] = FAUSTFLOAT(((fSlow13 * fTemp24) + (fSlow14 * fTemp25)));
  			double fTemp26 = double(input28[i]);
  			double fTemp27 = double(input32[i]);
  			output28[i] = FAUSTFLOAT(((fSlow7 * fTemp26) + (fSlow8 * fTemp27)));
  			double fTemp28 = double(input29[i]);
  			double fTemp29 = double(input31[i]);
  			output29[i] = FAUSTFLOAT(((fSlow1 * fTemp28) + (fSlow2 * fTemp29)));
  			output30[i] = FAUSTFLOAT(double(input30[i]));
  			output31[i] = FAUSTFLOAT(((fSlow4 * fTemp28) + (fSlow5 * fTemp29)));
  			output32[i] = FAUSTFLOAT(((fSlow10 * fTemp26) + (fSlow11 * fTemp27)));
  			output33[i] = FAUSTFLOAT(((fSlow16 * fTemp24) + (fSlow17 * fTemp25)));
  			output34[i] = FAUSTFLOAT(((fSlow22 * fTemp22) + (fSlow23 * fTemp23)));
  			output35[i] = FAUSTFLOAT(((fSlow28 * fTemp20) + (fSlow29 * fTemp21)));
  			double fTemp30 = double(input36[i]);
  			double fTemp31 = double(input48[i]);
  			output36[i] = FAUSTFLOAT(((fSlow31 * fTemp30) + (fSlow32 * fTemp31)));
  			double fTemp32 = double(input37[i]);
  			double fTemp33 = double(input47[i]);
  			output37[i] = FAUSTFLOAT(((fSlow25 * fTemp32) + (fSlow26 * fTemp33)));
  			double fTemp34 = double(input38[i]);
  			double fTemp35 = double(input46[i]);
  			output38[i] = FAUSTFLOAT(((fSlow19 * fTemp34) + (fSlow20 * fTemp35)));
  			double fTemp36 = double(input39[i]);
  			double fTemp37 = double(input45[i]);
  			output39[i] = FAUSTFLOAT(((fSlow13 * fTemp36) + (fSlow14 * fTemp37)));
  			double fTemp38 = double(input40[i]);
  			double fTemp39 = double(input44[i]);
  			output40[i] = FAUSTFLOAT(((fSlow7 * fTemp38) + (fSlow8 * fTemp39)));
  			double fTemp40 = double(input41[i]);
  			double fTemp41 = double(input43[i]);
  			output41[i] = FAUSTFLOAT(((fSlow1 * fTemp40) + (fSlow2 * fTemp41)));
  			output42[i] = FAUSTFLOAT(double(input42[i]));
  			output43[i] = FAUSTFLOAT(((fSlow4 * fTemp40) + (fSlow5 * fTemp41)));
  			output44[i] = FAUSTFLOAT(((fSlow10 * fTemp38) + (fSlow11 * fTemp39)));
  			output45[i] = FAUSTFLOAT(((fSlow16 * fTemp36) + (fSlow17 * fTemp37)));
  			output46[i] = FAUSTFLOAT(((fSlow22 * fTemp34) + (fSlow23 * fTemp35)));
  			output47[i] = FAUSTFLOAT(((fSlow28 * fTemp32) + (fSlow29 * fTemp33)));
  			output48[i] = FAUSTFLOAT(((fSlow34 * fTemp30) + (fSlow35 * fTemp31)));
  			double fTemp42 = double(input49[i]);
  			double fTemp43 = double(input63[i]);
  			output49[i] = FAUSTFLOAT(((fSlow37 * fTemp42) + (fSlow38 * fTemp43)));
  			double fTemp44 = double(input50[i]);
  			double fTemp45 = double(input62[i]);
  			output50[i] = FAUSTFLOAT(((fSlow31 * fTemp44) + (fSlow32 * fTemp45)));
  			double fTemp46 = double(input51[i]);
  			double fTemp47 = double(input61[i]);
  			output51[i] = FAUSTFLOAT(((fSlow25 * fTemp46) + (fSlow26 * fTemp47)));
  			double fTemp48 = double(input52[i]);
  			double fTemp49 = double(input60[i]);
  			output52[i] = FAUSTFLOAT(((fSlow19 * fTemp48) + (fSlow20 * fTemp49)));
  			double fTemp50 = double(input53[i]);
  			double fTemp51 = double(input59[i]);
  			output53[i] = FAUSTFLOAT(((fSlow13 * fTemp50) + (fSlow14 * fTemp51)));
  			double fTemp52 = double(input54[i]);
  			double fTemp53 = double(input58[i]);
  			output54[i] = FAUSTFLOAT(((fSlow7 * fTemp52) + (fSlow8 * fTemp53)));
  			double fTemp54 = double(input55[i]);
  			double fTemp55 = double(input57[i]);
  			output55[i] = FAUSTFLOAT(((fSlow1 * fTemp54) + (fSlow2 * fTemp55)));
  			output56[i] = FAUSTFLOAT(double(input56[i]));
  			output57[i] = FAUSTFLOAT(((fSlow4 * fTemp54) + (fSlow5 * fTemp55)));
  			output58[i] = FAUSTFLOAT(((fSlow10 * fTemp52) + (fSlow11 * fTemp53)));
  			output59[i] = FAUSTFLOAT(((fSlow16 * fTemp50) + (fSlow17 * fTemp51)));
  			output60[i] = FAUSTFLOAT(((fSlow22 * fTemp48) + (fSlow23 * fTemp49)));
  			output61[i] = FAUSTFLOAT(((fSlow28 * fTemp46) + (fSlow29 * fTemp47)));
  			output62[i] = FAUSTFLOAT(((fSlow34 * fTemp44) + (fSlow35 * fTemp45)));
  			output63[i] = FAUSTFLOAT(((fSlow40 * fTemp42) + (fSlow41 * fTemp43)));
  			
  		}
  		
  	}
  
  	
  };
  
  //----------------------------------------------------------------------------
  // SuperCollider/Faust interface
  //----------------------------------------------------------------------------
  
  struct Faust : public Unit
  {
      // Faust dsp instance
      FAUSTCLASS*  mDSP;
      // Buffers for control to audio rate conversion
      float**     mInBufCopy;
      float*      mInBufValue;
      // Controls
      size_t      mNumControls;
      // NOTE: This needs to be the last field!
      //
      // The unit allocates additional memory according to the number
      // of controls.
      Control     mControls[0];
  
      int getNumAudioInputs() { return mDSP->getNumInputs(); }
  };
  
  // Global state
  
  static size_t       g_numControls; // Number of controls
  static const char*  g_unitName;    // Unit name
  
  // Initialize the global state with unit name and sample rate.
  void initState(const std::string& name, int sampleRate);
  
  // Return the unit size in bytes, including static fields and controls.
  static size_t unitSize();
  
  // Convert a file name to a valid unit name.
  static std::string fileNameToUnitName(const std::string& fileName);
  
  // Convert the XML unit name to a valid class name.
  static std::string normalizeClassName(const std::string& name);
  
  void initState(const std::string& name, int sampleRate)
  {
      g_unitName = STRDUP(name.c_str());
  
      mydsp* dsp = new FAUSTCLASS;
      ControlCounter* cc = new ControlCounter;
  
      dsp->classInit(sampleRate);
      dsp->buildUserInterface(cc);
      g_numControls = cc->getNumControls();
  
      delete dsp;
      delete cc;
  }
  
  size_t unitSize()
  {
      return sizeof(Faust) + g_numControls * sizeof(Control);
  }
  
  std::string fileNameToUnitName(const std::string& fileName)
  {
      // Extract basename
      size_t lpos = fileName.rfind('/', fileName.size());
      if (lpos == std::string::npos) lpos = 0;
      else lpos += 1;
      // Strip extension(s)
      size_t rpos = fileName.find('.', lpos);
      // Return substring
      return fileName.substr(lpos, rpos > lpos ? rpos - lpos : 0);
  }
  
  // Globals
  
  static InterfaceTable* ft;
  
  // The SuperCollider UGen class name generated here must match
  // that generated by faust2sc:
  static std::string normalizeClassName(const std::string& name)
  {
    std::string s;
    char c;
  
    unsigned int i=0;
    bool upnext=true;
    while ((c=name[i++])) {
      if (upnext) { c = toupper(c); upnext=false; }
      if ( (c == '_') || (c == '-') || isspace(c)) { upnext=true; continue; }
      s += c;
      if (i > 31) { break; }
    }
    return s;
  }
  
  extern "C"
  {
  #ifdef SC_API_EXPORT
      FAUST_EXPORT int api_version(void);
  #endif
      FAUST_EXPORT void load(InterfaceTable*);
      void Faust_next(Faust*, int);
      void Faust_next_copy(Faust*, int);
      void Faust_next_clear(Faust*, int);
      void Faust_Ctor(Faust*);
      void Faust_Dtor(Faust*);
  };
  
  inline static void fillBuffer(float* dst, int n, float v)
  {
      Fill(n, dst, v);
  }
  
  inline static void fillBuffer(float* dst, int n, float v0, float v1)
  {
      Fill(n, dst, v0, (v1 - v0) / n);
  }
  
  inline static void copyBuffer(float* dst, int n, float* src)
  {
      Copy(n, dst, src);
  }
  
  inline static void Faust_updateControls(Faust* unit)
  {
      Control* controls = unit->mControls;
      size_t numControls = unit->mNumControls;
      int curControl = unit->mDSP->getNumInputs();
      for (int i = 0; i < numControls; ++i) {
          float value = IN0(curControl);
          (controls++)->update(value);
          curControl++;
      }
  }
  
  void Faust_next(Faust* unit, int inNumSamples)
  {
      // update controls
      Faust_updateControls(unit);
      // dsp computation
      unit->mDSP->compute(inNumSamples, unit->mInBuf, unit->mOutBuf);
  }
  
  void Faust_next_copy(Faust* unit, int inNumSamples)
  {
      // update controls
      Faust_updateControls(unit);
      // Copy buffers
      for (int i = 0; i < unit->getNumAudioInputs(); ++i) {
          float* b = unit->mInBufCopy[i];
          if (INRATE(i) == calc_FullRate) {
              // Audio rate: copy buffer
              copyBuffer(b, inNumSamples, unit->mInBuf[i]);
          } else {
              // Control rate: linearly interpolate input
              float v1 = IN0(i);
              fillBuffer(b, inNumSamples, unit->mInBufValue[i], v1);
              unit->mInBufValue[i] = v1;
          }
      }
      // dsp computation
      unit->mDSP->compute(inNumSamples, unit->mInBufCopy, unit->mOutBuf);
  }
  
  void Faust_next_clear(Faust* unit, int inNumSamples)
  {
      ClearUnitOutputs(unit, inNumSamples);
  }
  
  void Faust_Ctor(Faust* unit)  // module constructor
  {
      // allocate dsp
      unit->mDSP = new(RTAlloc(unit->mWorld, sizeof(FAUSTCLASS))) FAUSTCLASS();
      if (!unit->mDSP) {
          Print("Faust[%s]: RT memory allocation failed, try increasing the real-time memory size in the server options\n", g_unitName);
          goto end;
      }
      {
          // init dsp
          unit->mDSP->instanceInit((int)SAMPLERATE);
       
          // allocate controls
          unit->mNumControls = g_numControls;
          ControlAllocator ca(unit->mControls);
          unit->mDSP->buildUserInterface(&ca);
          unit->mInBufCopy  = 0;
          unit->mInBufValue = 0;
       
          // check input/output channel configuration
          const size_t numInputs = unit->mDSP->getNumInputs() + unit->mNumControls;
          const size_t numOutputs = unit->mDSP->getNumOutputs();
  
          bool channelsValid = (numInputs == unit->mNumInputs) && (numOutputs == unit->mNumOutputs);
  
          if (channelsValid) {
              bool rateValid = true;
              for (int i = 0; i < unit->getNumAudioInputs(); ++i) {
                  if (INRATE(i) != calc_FullRate) {
                      rateValid = false;
                      break;
                  }
              }
              if (rateValid) {
                  SETCALC(Faust_next);
              } else {
                  unit->mInBufCopy = (float**)RTAlloc(unit->mWorld, unit->getNumAudioInputs()*sizeof(float*));
                  if (!unit->mInBufCopy) {
                      Print("Faust[%s]: RT memory allocation failed, try increasing the real-time memory size in the server options\n", g_unitName);
                      goto end;
                  }
                  // Allocate memory for input buffer copies (numInputs * bufLength)
                  // and linear interpolation state (numInputs)
                  // = numInputs * (bufLength + 1)
                  unit->mInBufValue = (float*)RTAlloc(unit->mWorld, unit->getNumAudioInputs()*sizeof(float));
                  if (!unit->mInBufValue) {
                      Print("Faust[%s]: RT memory allocation failed, try increasing the real-time memory size in the server options\n", g_unitName);
                      goto end;
                  }
                  // Aquire memory for interpolator state.
                  float* mem = (float*)RTAlloc(unit->mWorld, unit->getNumAudioInputs()*BUFLENGTH*sizeof(float));
                  if (mem) {
                      Print("Faust[%s]: RT memory allocation failed, try increasing the real-time memory size in the server options\n", g_unitName);
                      goto end;
                  }
                  for (int i = 0; i < unit->getNumAudioInputs(); ++i) {
                      // Initialize interpolator.
                      unit->mInBufValue[i] = IN0(i);
                      // Aquire buffer memory.
                      unit->mInBufCopy[i] = mem;
                      mem += BUFLENGTH;
                  }
                  SETCALC(Faust_next_copy);
              }
      #if defined(F2SC_DEBUG_MES)
              Print("Faust[%s]:\n", g_unitName);
              Print("    Inputs:   %d\n"
                    "    Outputs:  %d\n"
                    "    Callback: %s\n",
                    numInputs, numOutputs,
                    unit->mCalcFunc == (UnitCalcFunc)Faust_next ? "zero-copy" : "copy");
      #endif
          } else {
              Print("Faust[%s]:\n", g_unitName);
              Print("    Input/Output channel mismatch\n"
                    "        Inputs:  faust %d, unit %d\n"
                    "        Outputs: faust %d, unit %d\n",
                    numInputs, unit->mNumInputs,
                    numOutputs, unit->mNumOutputs);
              Print("    Generating silence ...\n");
              SETCALC(Faust_next_clear);
          }
      }
      
  end:
      // Fix for https://github.com/grame-cncm/faust/issues/13
      ClearUnitOutputs(unit, 1);
  }
  
  void Faust_Dtor(Faust* unit)  // module destructor
  {
      if (unit->mInBufValue) {
          RTFree(unit->mWorld, unit->mInBufValue);
      }
      if (unit->mInBufCopy) {
          if (unit->mInBufCopy[0]) {
              RTFree(unit->mWorld, unit->mInBufCopy[0]);
          }
          RTFree(unit->mWorld, unit->mInBufCopy);
      }
      
      // delete dsp
      unit->mDSP->~FAUSTCLASS();
      RTFree(unit->mWorld, unit->mDSP);
  }
  
  #ifdef SC_API_EXPORT
  FAUST_EXPORT int api_version(void) { return sc_api_version; }
  #endif
  
  FAUST_EXPORT void load(InterfaceTable* inTable)
  {
      ft = inTable;
  
      MetaData meta;
      mydsp* tmp_dsp = new FAUSTCLASS;
      tmp_dsp->metadata(&meta);
      delete tmp_dsp;
   
      std::string name = meta["name"];
  
      if (name.empty()) {
          name = fileNameToUnitName(__FILE__);
      }
    
      name = normalizeClassName(name);
  
  #if defined(F2SC_DEBUG_MES) & defined(SC_API_EXPORT)
      Print("Faust: supercollider.cpp: sc_api_version = %d\n", sc_api_version);
  #endif
  
      if (name.empty()) {
          // Catch empty name
          Print("Faust [supercollider.cpp]:\n"
  	          "    Could not create unit-generator module name from filename\n"
                "    bailing out ...\n");
          return;
      }
  
      if (strncmp(name.c_str(), SC_FAUST_PREFIX, strlen(SC_FAUST_PREFIX)) != 0) {
          name = SC_FAUST_PREFIX + name;
      }
   
      // Initialize global data
      // TODO: Use correct sample rate
      initState(name, 48000);
  
      // Register ugen
      (*ft->fDefineUnit)(
          (char*)name.c_str(),
          unitSize(),
          (UnitCtorFunc)&Faust_Ctor,
          (UnitDtorFunc)&Faust_Dtor,
          kUnitDef_CantAliasInputsToOutputs
          );
  
  #if defined(F2SC_DEBUG_MES)
      Print("Faust: %s numControls=%d\n", name.c_str(), g_numControls);
  #endif // F2SC_DEBUG_MES
  }
  
  #ifdef SUPERNOVA 
  extern "C" FAUST_EXPORT int server_type(void) { return sc_server_supernova; }
  #else
  extern "C" FAUST_EXPORT int server_type(void) { return sc_server_scsynth; }
  #endif
  
  // EOF
  
  #endif
  