@grame/faustwasm 0.5.2 → 0.5.3

package/foo.cpp

@@ -0,0 +1,3312 @@
+
+#include <cstdint>
+#include <cmath>
+#include <cassert>
+#include <string>
+#include <cstring>
+#include <array>
+
+//==============================================================================
+/// Auto-generated C++ class for the 'HelloReverb' processor
+///
+
+#if ! (defined (__cplusplus) && (__cplusplus >= 201703L))
+ #error "This code requires that your compiler is set to use C++17 or later!"
+#endif
+
+struct HelloReverb
+{
+    HelloReverb() = default;
+    ~HelloReverb() = default;
+
+    static constexpr std::string_view name = "HelloReverb";
+
+    //==============================================================================
+    using EndpointHandle = uint32_t;
+
+    enum class EndpointType
+    {
+        stream,
+        event,
+        value
+    };
+
+    struct EndpointInfo
+    {
+        uint32_t handle;
+        const char* name;
+        EndpointType endpointType;
+    };
+
+    //==============================================================================
+    static constexpr uint32_t numInputEndpoints  = 11;
+    static constexpr uint32_t numOutputEndpoints = 2;
+
+    static constexpr uint32_t maxFramesPerBlock  = 512;
+    static constexpr uint32_t eventBufferSize    = 32;
+    static constexpr uint32_t maxOutputEventSize = 0;
+    static constexpr double   latency            = 0.000000;
+
+    enum class EndpointHandles
+    {
+        out0          = 12,
+        out1          = 13,
+        freq          = 1 ,
+        bend          = 2 ,
+        gain          = 3 ,
+        envAttack     = 4 ,
+        sustain       = 5 ,
+        reedStiffness = 6 ,
+        bellOpening   = 7 ,
+        vibratoFreq   = 8 ,
+        vibratoGain   = 9 ,
+        outGain       = 10,
+        gate          = 11
+    };
+
+    static constexpr uint32_t getEndpointHandleForName (std::string_view endpointName)
+    {
+        if (endpointName == "out0")           return static_cast<uint32_t> (EndpointHandles::out0);
+        if (endpointName == "out1")           return static_cast<uint32_t> (EndpointHandles::out1);
+        if (endpointName == "freq")           return static_cast<uint32_t> (EndpointHandles::freq);
+        if (endpointName == "bend")           return static_cast<uint32_t> (EndpointHandles::bend);
+        if (endpointName == "gain")           return static_cast<uint32_t> (EndpointHandles::gain);
+        if (endpointName == "envAttack")      return static_cast<uint32_t> (EndpointHandles::envAttack);
+        if (endpointName == "sustain")        return static_cast<uint32_t> (EndpointHandles::sustain);
+        if (endpointName == "reedStiffness")  return static_cast<uint32_t> (EndpointHandles::reedStiffness);
+        if (endpointName == "bellOpening")    return static_cast<uint32_t> (EndpointHandles::bellOpening);
+        if (endpointName == "vibratoFreq")    return static_cast<uint32_t> (EndpointHandles::vibratoFreq);
+        if (endpointName == "vibratoGain")    return static_cast<uint32_t> (EndpointHandles::vibratoGain);
+        if (endpointName == "outGain")        return static_cast<uint32_t> (EndpointHandles::outGain);
+        if (endpointName == "gate")           return static_cast<uint32_t> (EndpointHandles::gate);
+        return 0;
+    }
+
+    static constexpr EndpointInfo inputEndpoints[] =
+    {
+        { 1,   "freq",           EndpointType::event },
+        { 2,   "bend",           EndpointType::event },
+        { 3,   "gain",           EndpointType::event },
+        { 4,   "envAttack",      EndpointType::event },
+        { 5,   "sustain",        EndpointType::event },
+        { 6,   "reedStiffness",  EndpointType::event },
+        { 7,   "bellOpening",    EndpointType::event },
+        { 8,   "vibratoFreq",    EndpointType::event },
+        { 9,   "vibratoGain",    EndpointType::event },
+        { 10,  "outGain",        EndpointType::event },
+        { 11,  "gate",           EndpointType::event }
+    };
+
+    static constexpr EndpointInfo outputEndpoints[] =
+    {
+        { 12,  "out0",  EndpointType::stream },
+        { 13,  "out1",  EndpointType::stream }
+    };
+
+    //==============================================================================
+    static constexpr uint32_t numAudioInputChannels  = 0;
+    static constexpr uint32_t numAudioOutputChannels = 2;
+
+    static constexpr std::array outputAudioStreams
+    {
+        outputEndpoints[0],
+        outputEndpoints[1]
+    };
+
+    static constexpr std::array<EndpointInfo, 0> outputEvents {};
+
+    static constexpr std::array<EndpointInfo, 0> outputMIDIEvents {};
+
+    static constexpr std::array<EndpointInfo, 0> inputAudioStreams {};
+
+    static constexpr std::array inputEvents
+    {
+        inputEndpoints[0],
+        inputEndpoints[1],
+        inputEndpoints[2],
+        inputEndpoints[3],
+        inputEndpoints[4],
+        inputEndpoints[5],
+        inputEndpoints[6],
+        inputEndpoints[7],
+        inputEndpoints[8],
+        inputEndpoints[9],
+        inputEndpoints[10]
+    };
+
+    static constexpr std::array<EndpointInfo, 0> inputMIDIEvents {};
+
+    static constexpr std::array inputParameters
+    {
+        inputEndpoints[0],
+        inputEndpoints[1],
+        inputEndpoints[2],
+        inputEndpoints[3],
+        inputEndpoints[4],
+        inputEndpoints[5],
+        inputEndpoints[6],
+        inputEndpoints[7],
+        inputEndpoints[8],
+        inputEndpoints[9],
+        inputEndpoints[10]
+    };
+
+    static constexpr const char* programDetailsJSON = "{\n"
+        "  \"mainProcessor\": \"HelloReverb\",\n"
+        "  \"inputs\": [\n"
+        "    {\n"
+        "      \"endpointID\": \"freq\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"freq\",\n"
+        "        \"min\": 50,\n"
+        "        \"max\": 1000,\n"
+        "        \"init\": 440,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"bend\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"bend\",\n"
+        "        \"min\": -2,\n"
+        "        \"max\": 2,\n"
+        "        \"init\": 0,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"gain\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"gain\",\n"
+        "        \"min\": 0,\n"
+        "        \"max\": 1,\n"
+        "        \"init\": 0.6,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"envAttack\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"envAttack\",\n"
+        "        \"min\": 0,\n"
+        "        \"max\": 30,\n"
+        "        \"init\": 1,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"sustain\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"sustain\",\n"
+        "        \"min\": 0,\n"
+        "        \"max\": 1,\n"
+        "        \"init\": 0,\n"
+        "        \"step\": 1\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"reedStiffness\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"reedStiffness\",\n"
+        "        \"min\": 0,\n"
+        "        \"max\": 1,\n"
+        "        \"init\": 0.5,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"bellOpening\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"bellOpening\",\n"
+        "        \"min\": 0,\n"
+        "        \"max\": 1,\n"
+        "        \"init\": 0.5,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"vibratoFreq\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"vibratoFreq\",\n"
+        "        \"min\": 1,\n"
+        "        \"max\": 10,\n"
+        "        \"init\": 5,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"vibratoGain\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"vibratoGain\",\n"
+        "        \"min\": 0,\n"
+        "        \"max\": 1,\n"
+        "        \"init\": 0.25,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"outGain\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"outGain\",\n"
+        "        \"min\": 0,\n"
+        "        \"max\": 1,\n"
+        "        \"init\": 0.5,\n"
+        "        \"step\": 0.01\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"gate\",\n"
+        "      \"endpointType\": \"event\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"annotation\": {\n"
+        "        \"name\": \"gate\",\n"
+        "        \"text\": \"off|on\",\n"
+        "        \"boolean\": true\n"
+        "      },\n"
+        "      \"purpose\": \"parameter\"\n"
+        "    }\n"
+        "  ],\n"
+        "  \"outputs\": [\n"
+        "    {\n"
+        "      \"endpointID\": \"out0\",\n"
+        "      \"endpointType\": \"stream\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"purpose\": \"audio out\",\n"
+        "      \"numAudioChannels\": 1\n"
+        "    },\n"
+        "    {\n"
+        "      \"endpointID\": \"out1\",\n"
+        "      \"endpointType\": \"stream\",\n"
+        "      \"dataType\": {\n"
+        "        \"type\": \"float32\"\n"
+        "      },\n"
+        "      \"purpose\": \"audio out\",\n"
+        "      \"numAudioChannels\": 1\n"
+        "    }\n"
+        "  ]\n"
+        "}";
+
+    //==============================================================================
+    struct intrinsics;
+
+    using SizeType = int32_t;
+    using IndexType = int32_t;
+    using StringHandle = uint32_t;
+
+    struct Null
+    {
+        template <typename AnyType> operator AnyType() const    { return {}; }
+        Null operator[] (IndexType) const                       { return {}; }
+    };
+
+    //==============================================================================
+    template <typename ElementType, SizeType numElements>
+    struct Array
+    {
+        Array() = default;
+        Array (Null) {}
+        Array (const Array&) = default;
+
+        template <typename ElementOrList>
+        Array (const ElementOrList& value) noexcept
+        {
+            if constexpr (std::is_convertible<ElementOrList, ElementType>::value)
+            {
+                for (IndexType i = 0; i < numElements; ++i)
+                    this->elements[i] = static_cast<ElementType> (value);
+            }
+            else
+            {
+                for (IndexType i = 0; i < numElements; ++i)
+                    this->elements[i] = static_cast<ElementType> (value[i]);
+            }
+        }
+
+        template <typename... Others>
+        Array (ElementType e0, ElementType e1, Others... others) noexcept
+        {
+            this->elements[0] = static_cast<ElementType> (e0);
+            this->elements[1] = static_cast<ElementType> (e1);
+
+            if constexpr (numElements > 2)
+            {
+                const ElementType initialisers[] = { static_cast<ElementType> (others)... };
+
+                for (size_t i = 0; i < sizeof...(others); ++i)
+                    this->elements[i + 2] = initialisers[i];
+            }
+        }
+
+        Array (const ElementType* rawArray, size_t) noexcept
+        {
+            for (IndexType i = 0; i < numElements; ++i)
+                this->elements[i] = rawArray[i];
+        }
+
+        Array& operator= (const Array&) noexcept = default;
+        Array& operator= (Null) noexcept                 { this->clear(); return *this; }
+
+        template <typename ElementOrList>
+        Array& operator= (const ElementOrList& value) noexcept
+        {
+            if constexpr (std::is_convertible<ElementOrList, ElementType>::value)
+            {
+                for (IndexType i = 0; i < numElements; ++i)
+                    this->elements[i] = static_cast<ElementType> (value);
+            }
+            else
+            {
+                for (IndexType i = 0; i < numElements; ++i)
+                    this->elements[i] = static_cast<ElementType> (value[i]);
+            }
+        }
+
+        static constexpr SizeType size()                                    { return numElements; }
+
+        const ElementType& operator[] (IndexType index) const noexcept      { return this->elements[index]; }
+        ElementType& operator[] (IndexType index) noexcept                  { return this->elements[index]; }
+
+        void clear() noexcept
+        {
+            for (auto& element : elements)
+                element = ElementType();
+        }
+
+        void clear (SizeType numElementsToClear) noexcept
+        {
+            for (SizeType i = 0; i < numElementsToClear; ++i)
+                elements[i] = ElementType();
+        }
+
+        ElementType elements[numElements] = {};
+    };
+
+    //==============================================================================
+    template <typename ElementType, SizeType numElements>
+    struct Vector  : public Array<ElementType, numElements>
+    {
+        Vector() = default;
+        Vector (Null) {}
+
+        template <typename ElementOrList>
+        Vector (const ElementOrList& value) noexcept  : Array<ElementType, numElements> (value) {}
+
+        template <typename... Others>
+        Vector (ElementType e0, ElementType e1, Others... others) noexcept  : Array<ElementType, numElements> (e0, e1, others...) {}
+
+        Vector (const ElementType* rawArray, size_t) noexcept  : Array<ElementType, numElements> (rawArray, size_t()) {}
+
+        template <typename ElementOrList>
+        Vector& operator= (const ElementOrList& value) noexcept { return Array<ElementType, numElements>::operator= (value); }
+
+        Vector& operator= (Null) noexcept { this->clear(); return *this; }
+
+        operator ElementType() const noexcept
+        {
+            static_assert (numElements == 1);
+            return this->elements[0];
+        }
+
+        constexpr auto operator!() const noexcept     { return performUnaryOp ([] (ElementType n) { return ! n; }); }
+        constexpr auto operator~() const noexcept     { return performUnaryOp ([] (ElementType n) { return ~n; }); }
+        constexpr auto operator-() const noexcept     { return performUnaryOp ([] (ElementType n) { return -n; }); }
+
+        constexpr auto operator+ (const Vector& rhs) const noexcept   { return performBinaryOp (rhs, [] (ElementType a, ElementType b) { return a + b; }); }
+        constexpr auto operator- (const Vector& rhs) const noexcept   { return performBinaryOp (rhs, [] (ElementType a, ElementType b) { return a - b; }); }
+        constexpr auto operator* (const Vector& rhs) const noexcept   { return performBinaryOp (rhs, [] (ElementType a, ElementType b) { return a * b; }); }
+        constexpr auto operator/ (const Vector& rhs) const noexcept   { return performBinaryOp (rhs, [] (ElementType a, ElementType b) { return a / b; }); }
+        constexpr auto operator% (const Vector& rhs) const noexcept   { return performBinaryOp (rhs, [] (ElementType a, ElementType b) { return intrinsics::modulo (a, b); }); }
+
+        constexpr auto operator== (const Vector& rhs) const noexcept  { return performComparison (rhs, [] (ElementType a, ElementType b) { return a == b; }); }
+        constexpr auto operator!= (const Vector& rhs) const noexcept  { return performComparison (rhs, [] (ElementType a, ElementType b) { return a != b; }); }
+        constexpr auto operator<  (const Vector& rhs) const noexcept  { return performComparison (rhs, [] (ElementType a, ElementType b) { return a < b; }); }
+        constexpr auto operator<= (const Vector& rhs) const noexcept  { return performComparison (rhs, [] (ElementType a, ElementType b) { return a <= b; }); }
+        constexpr auto operator>  (const Vector& rhs) const noexcept  { return performComparison (rhs, [] (ElementType a, ElementType b) { return a > b; }); }
+        constexpr auto operator>= (const Vector& rhs) const noexcept  { return performComparison (rhs, [] (ElementType a, ElementType b) { return a >= b; }); }
+
+        template <typename Functor>
+        constexpr Vector performUnaryOp (Functor&& f) const noexcept
+        {
+            Vector result;
+
+            for (IndexType i = 0; i < numElements; ++i)
+                result.elements[i] = f (this->elements[i]);
+
+            return result;
+        }
+
+        template <typename Functor>
+        constexpr Vector performBinaryOp (const Vector& rhs, Functor&& f) const noexcept
+        {
+            Vector result;
+
+            for (IndexType i = 0; i < numElements; ++i)
+                result.elements[i] = f (this->elements[i], rhs.elements[i]);
+
+            return result;
+        }
+
+        template <typename Functor>
+        constexpr Vector<bool, numElements> performComparison (const Vector& rhs, Functor&& f) const noexcept
+        {
+            Vector<bool, numElements> result;
+
+            for (IndexType i = 0; i < numElements; ++i)
+                result.elements[i] = f (this->elements[i], rhs.elements[i]);
+
+            return result;
+        }
+    };
+
+    //==============================================================================
+    template <typename ElementType>
+    struct Slice
+    {
+        Slice() = default;
+        Slice (Null) {}
+        Slice (ElementType* e, SizeType size) : elements (e), numElements (size) {}
+        Slice (const Slice&) = default;
+        Slice& operator= (const Slice&) = default;
+        template <typename ArrayType> Slice (const ArrayType& a) : elements (const_cast<ArrayType&> (a).elements), numElements (a.size()) {}
+        template <typename ArrayType> Slice (const ArrayType& a, SizeType offset, SizeType size) : elements (const_cast<ArrayType&> (a).elements + offset), numElements (size) {}
+
+        constexpr SizeType size() const                                     { return numElements; }
+        ElementType operator[] (IndexType index) const noexcept             { return numElements == 0 ? ElementType() : elements[index]; }
+        ElementType& operator[] (IndexType index) noexcept                  { return numElements == 0 ? emptyValue : elements[index]; }
+
+        Slice slice (IndexType start, IndexType end) noexcept               { if (numElements == 0) return {}; return { elements + start, end }; }
+        Slice sliceFrom (IndexType start) noexcept                          { if (numElements == 0) return {}; return { elements + start, numElements - start }; }
+        Slice sliceUpTo (IndexType end) noexcept                            { if (numElements == 0) return {}; return { elements, end }; }
+
+        ElementType* elements = nullptr;
+        SizeType numElements = 0;
+
+        static inline ElementType emptyValue {};
+    };
+
+    //==============================================================================
+    #if __clang__
+     #pragma clang diagnostic push
+     #pragma clang diagnostic ignored "-Wunused-variable"
+     #pragma clang diagnostic ignored "-Wunused-parameter"
+     #pragma clang diagnostic ignored "-Wunused-label"
+
+     #if __clang_major__ >= 14
+      #pragma clang diagnostic ignored "-Wunused-but-set-variable"
+     #endif
+
+    #elif __GNUC__
+     #pragma GCC diagnostic push
+     #pragma GCC diagnostic ignored "-Wunused-variable"
+     #pragma GCC diagnostic ignored "-Wunused-parameter"
+     #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+     #pragma GCC diagnostic ignored "-Wunused-label"
+    #else
+     #pragma warning (push, 0)
+     #pragma warning (disable: 4702)
+     #pragma warning (disable: 4706)
+    #endif
+
+    //==============================================================================
+    struct _HelloWorld_1_State
+    {
+        int32_t framesPerQuarterNote = {};
+        float phase = {};
+        int32_t i = {};
+        float phaseDelta = {};
+        int32_t _count = {};
+        int32_t _resumeIndex = {};
+    };
+
+    struct faust_reverb_1_State
+    {
+        int32_t fSampleRate = {};
+        float fConst0 = {};
+        float fConst1 = {};
+        float fVslider0 = {};
+        float fSlow0 = {};
+        float fConst2 = {};
+        Array<float, 2> fRec0;
+        int32_t IOTA0 = {};
+        Array<float, 16384> fVec0;
+        float fVslider1 = {};
+        float fSlow1 = {};
+        Array<float, 2> fRec1;
+        float fConst3 = {};
+        float fVslider2 = {};
+        float fSlow2 = {};
+        float fVslider3 = {};
+        float fSlow3 = {};
+        float fSlow4 = {};
+        float fSlow5 = {};
+        float fConst4 = {};
+        float fConst5 = {};
+        float fVslider4 = {};
+        float fSlow6 = {};
+        float fSlow7 = {};
+        float fVslider5 = {};
+        float fSlow8 = {};
+        float fSlow9 = {};
+        float fSlow10 = {};
+        float fSlow11 = {};
+        float fSlow12 = {};
+        float fSlow13 = {};
+        float fSlow14 = {};
+        float fVslider6 = {};
+        float fSlow15 = {};
+        float fSlow16 = {};
+        float fConst6 = {};
+        float fVslider7 = {};
+        float fSlow17 = {};
+        float fSlow18 = {};
+        float fSlow19 = {};
+        Array<float, 2> fRec15;
+        float fSlow20 = {};
+        Array<float, 2> fRec14;
+        Array<float, 32768> fVec1;
+        float fConst7 = {};
+        int32_t iConst8 = {};
+        Array<float, 16384> fVec2;
+        float fConst9 = {};
+        float fVslider8 = {};
+        int32_t iSlow21 = {};
+        Array<float, 2048> fVec3;
+        int32_t iConst10 = {};
+        Array<float, 2> fRec12;
+        float fConst11 = {};
+        float fConst12 = {};
+        float fSlow22 = {};
+        float fSlow23 = {};
+        float fSlow24 = {};
+        float fSlow25 = {};
+        float fSlow26 = {};
+        float fSlow27 = {};
+        float fSlow28 = {};
+        float fSlow29 = {};
+        Array<float, 2> fRec19;
+        float fSlow30 = {};
+        Array<float, 2> fRec18;
+        Array<float, 32768> fVec4;
+        float fConst13 = {};
+        int32_t iConst14 = {};
+        Array<float, 4096> fVec5;
+        int32_t iConst15 = {};
+        Array<float, 2> fRec16;
+        float fConst16 = {};
+        float fConst17 = {};
+        float fSlow31 = {};
+        float fSlow32 = {};
+        float fSlow33 = {};
+        float fSlow34 = {};
+        float fSlow35 = {};
+        float fSlow36 = {};
+        float fSlow37 = {};
+        float fSlow38 = {};
+        Array<float, 2> fRec23;
+        float fSlow39 = {};
+        Array<float, 2> fRec22;
+        Array<float, 16384> fVec6;
+        float fConst18 = {};
+        int32_t iConst19 = {};
+        Array<float, 4096> fVec7;
+        int32_t iConst20 = {};
+        Array<float, 2> fRec20;
+        float fConst21 = {};
+        float fConst22 = {};
+        float fSlow40 = {};
+        float fSlow41 = {};
+        float fSlow42 = {};
+        float fSlow43 = {};
+        float fSlow44 = {};
+        float fSlow45 = {};
+        float fSlow46 = {};
+        float fSlow47 = {};
+        Array<float, 2> fRec27;
+        float fSlow48 = {};
+        Array<float, 2> fRec26;
+        Array<float, 32768> fVec8;
+        float fConst23 = {};
+        int32_t iConst24 = {};
+        Array<float, 4096> fVec9;
+        int32_t iConst25 = {};
+        Array<float, 2> fRec24;
+        float fConst26 = {};
+        float fConst27 = {};
+        float fSlow49 = {};
+        float fSlow50 = {};
+        float fSlow51 = {};
+        float fSlow52 = {};
+        float fSlow53 = {};
+        float fSlow54 = {};
+        float fSlow55 = {};
+        float fSlow56 = {};
+        Array<float, 2> fRec31;
+        float fSlow57 = {};
+        Array<float, 2> fRec30;
+        Array<float, 16384> fVec10;
+        float fConst28 = {};
+        int32_t iConst29 = {};
+        Array<float, 2048> fVec11;
+        int32_t iConst30 = {};
+        Array<float, 2> fRec28;
+        float fConst31 = {};
+        float fConst32 = {};
+        float fSlow58 = {};
+        float fSlow59 = {};
+        float fSlow60 = {};
+        float fSlow61 = {};
+        float fSlow62 = {};
+        float fSlow63 = {};
+        float fSlow64 = {};
+        float fSlow65 = {};
+        Array<float, 2> fRec35;
+        float fSlow66 = {};
+        Array<float, 2> fRec34;
+        Array<float, 16384> fVec12;
+        float fConst33 = {};
+        int32_t iConst34 = {};
+        Array<float, 4096> fVec13;
+        int32_t iConst35 = {};
+        Array<float, 2> fRec32;
+        float fConst36 = {};
+        float fConst37 = {};
+        float fSlow67 = {};
+        float fSlow68 = {};
+        float fSlow69 = {};
+        float fSlow70 = {};
+        float fSlow71 = {};
+        float fSlow72 = {};
+        float fSlow73 = {};
+        float fSlow74 = {};
+        Array<float, 2> fRec39;
+        float fSlow75 = {};
+        Array<float, 2> fRec38;
+        Array<float, 16384> fVec14;
+        float fConst38 = {};
+        int32_t iConst39 = {};
+        Array<float, 4096> fVec15;
+        int32_t iConst40 = {};
+        Array<float, 2> fRec36;
+        float fConst41 = {};
+        float fConst42 = {};
+        float fSlow76 = {};
+        float fSlow77 = {};
+        float fSlow78 = {};
+        float fSlow79 = {};
+        float fSlow80 = {};
+        float fSlow81 = {};
+        float fSlow82 = {};
+        float fSlow83 = {};
+        Array<float, 2> fRec43;
+        float fSlow84 = {};
+        Array<float, 2> fRec42;
+        Array<float, 16384> fVec16;
+        float fConst43 = {};
+        int32_t iConst44 = {};
+        Array<float, 2048> fVec17;
+        int32_t iConst45 = {};
+        Array<float, 2> fRec40;
+        Array<float, 3> fRec4;
+        Array<float, 3> fRec5;
+        Array<float, 3> fRec6;
+        Array<float, 3> fRec7;
+        Array<float, 3> fRec8;
+        Array<float, 3> fRec9;
+        Array<float, 3> fRec10;
+        Array<float, 3> fRec11;
+        float fSlow85 = {};
+        Array<float, 3> fRec3;
+        float fVslider9 = {};
+        float fSlow86 = {};
+        float fVslider10 = {};
+        float fSlow87 = {};
+        float fSlow88 = {};
+        float fSlow89 = {};
+        float fSlow90 = {};
+        Array<float, 3> fRec2;
+        Array<float, 3> fRec45;
+        Array<float, 3> fRec44;
+        bool fUpdated = {};
+        int32_t _resumeIndex = {};
+    };
+
+    struct faust_echo_1_State
+    {
+        int32_t IOTA0 = {};
+        int32_t fSampleRate = {};
+        float fConst0 = {};
+        float fVslider0 = {};
+        int32_t iSlow0 = {};
+        Array<float, 2097152> fRec0;
+        Array<float, 2097152> fRec1;
+        bool fUpdated = {};
+        int32_t _resumeIndex = {};
+    };
+
+    struct faust_voice_1_State
+    {
+        float fHslider0 = {};
+        float fSlow0 = {};
+        Array<int32_t, 2> iRec6;
+        float fHslider1 = {};
+        float fSlow1 = {};
+        float fSlow2 = {};
+        Array<int32_t, 2> iVec0;
+        Array<float, 2> fRec12;
+        int32_t fSampleRate = {};
+        float fConst0 = {};
+        float fConst1 = {};
+        float fHslider2 = {};
+        float fSlow3 = {};
+        float fHslider3 = {};
+        float fSlow4 = {};
+        float fButton0 = {};
+        float fHslider4 = {};
+        float fSlow5 = {};
+        Array<float, 2> fVec1;
+        int32_t iSlow6 = {};
+        Array<float, 2> fRec13;
+        float fHslider5 = {};
+        float fSlow7 = {};
+        float fHslider6 = {};
+        float fHslider7 = {};
+        float fSlow8 = {};
+        int32_t iSlow9 = {};
+        float fConst2 = {};
+        float fSlow10 = {};
+        float fSlow11 = {};
+        Array<float, 2> fRec14;
+        float fHslider8 = {};
+        float fSlow12 = {};
+        Array<float, 2> fRec16;
+        float fConst3 = {};
+        float fConst4 = {};
+        float fConst5 = {};
+        float fConst6 = {};
+        Array<int32_t, 2> iRec20;
+        float fConst7 = {};
+        float fConst8 = {};
+        float fConst9 = {};
+        Array<float, 3> fRec19;
+        Array<float, 2> fRec17;
+        float fHslider9 = {};
+        float fSlow13 = {};
+        int32_t IOTA0 = {};
+        Array<float, 2048> fRec18;
+        float fConst10 = {};
+        Array<float, 2> fVec3;
+        Array<float, 2> fRec11;
+        Array<float, 2048> fRec2;
+        Array<float, 2> fRec0;
+        bool fUpdated = {};
+        Array<float, 65536> ftbl0voiceSIG0;
+        int32_t _resumeIndex = {};
+    };
+
+    struct _HelloReverb_State
+    {
+        int32_t _sessionID = {};
+        double _frequency = {};
+        _HelloWorld_1_State Hello;
+        faust_reverb_1_State Reverb;
+        faust_echo_1_State Echo;
+        faust_voice_1_State Clarinet;
+    };
+
+    struct HelloReverb_State
+    {
+        int32_t _currentFrame = {};
+        _HelloReverb_State _state;
+    };
+
+    struct faust_voice_1_voiceSIG0
+    {
+        Array<int32_t, 2> iVec2;
+        Array<int32_t, 2> iRec15;
+    };
+
+    struct HelloReverb_IO
+    {
+        Array<float, 512> out0;
+        Array<float, 512> out1;
+    };
+
+    struct _HelloReverb_IO
+    {
+        float out0 = {};
+        float out1 = {};
+    };
+
+    struct _HelloWorld_1_IO
+    {
+        float out = {};
+    };
+
+    struct faust_reverb_1_IO
+    {
+        float input0 = {};
+        float input1 = {};
+        float output0 = {};
+        float output1 = {};
+    };
+
+    struct faust_voice_1_IO
+    {
+        float output0 = {};
+        float output1 = {};
+    };
+
+    struct _HelloWorld_1_Note
+    {
+        int32_t pitch = {};
+        int32_t length = {};
+    };
+
+    using std_intrinsics_T = float;
+    using std_intrinsics_T_0 = float;
+    using std_intrinsics_T_1 = float;
+    using std_intrinsics_T_2 = float;
+    using std_intrinsics_T_3 = float;
+    using std_intrinsics_T_4 = float;
+    using std_intrinsics_T_5 = float;
+    using std_notes_T = int32_t;
+    using std_intrinsics_T_6 = float;
+    using std_intrinsics_T_7 = float;
+    using std_intrinsics_T_8 = float;
+    using std_intrinsics_T_9 = float;
+    using std_intrinsics_T_10 = int32_t;
+    using std_intrinsics_T_11 = int32_t;
+    using std_intrinsics_T_12 = float;
+
+    //==============================================================================
+    double getMaxFrequency() const
+    {
+        return 192000.0;
+    }
+
+    void initialise (int32_t sessionID, double frequency)
+    {
+        assert (frequency <= getMaxFrequency());
+        initSessionID = sessionID;
+        initFrequency = frequency;
+        reset();
+    }
+
+    void reset()
+    {
+        std::memset (&state, 0, sizeof (state));
+        int32_t processorID = 0;
+        _initialise (state, processorID, initSessionID, initFrequency);
+    }
+
+    void advance (int32_t frames)
+    {
+        io.out0.clear (static_cast<SizeType> (frames));
+        io.out1.clear (static_cast<SizeType> (frames));
+        _advance (state, io, frames);
+    }
+
+    void copyOutputValue (EndpointHandle endpointHandle, void* dest)
+    {
+        (void) endpointHandle; (void) dest;
+
+        assert (false);
+    }
+
+    void copyOutputFrames (EndpointHandle endpointHandle, void* dest, uint32_t numFramesToCopy)
+    {
+        if (endpointHandle == 12) { std::memcpy (dest, std::addressof (io.out0), 4 * numFramesToCopy); std::memset (std::addressof (io.out0), 0, 4 * numFramesToCopy); return; }
+        if (endpointHandle == 13) { std::memcpy (dest, std::addressof (io.out1), 4 * numFramesToCopy); std::memset (std::addressof (io.out1), 0, 4 * numFramesToCopy); return; }
+        assert (false);
+    }
+
+    uint32_t getNumOutputEvents (EndpointHandle endpointHandle)
+    {
+        (void) endpointHandle;
+
+        assert (false); return {};
+    }
+
+    void resetOutputEventCount (EndpointHandle endpointHandle)
+    {
+        (void) endpointHandle;
+    }
+
+    uint32_t getOutputEventType (EndpointHandle endpointHandle, uint32_t index)
+    {
+        (void) endpointHandle; (void) index;
+
+        assert (false); return {};
+    }
+
+    static uint32_t getOutputEventDataSize (EndpointHandle endpointHandle, uint32_t typeIndex)
+    {
+        (void) endpointHandle; (void) typeIndex;
+
+        assert (false); return 0;
+    }
+
+    uint32_t readOutputEvent (EndpointHandle endpointHandle, uint32_t index, unsigned char* dest)
+    {
+
+        (void) endpointHandle; (void) index; (void) dest;
+
+        assert (false);
+        return {};
+    }
+
+    void addEvent_freq (float event)
+    {
+        _sendEvent_freq (state, event);
+    }
+
+    void addEvent_gate (float event)
+    {
+        _sendEvent_gate (state, event);
+    }
+
+    void addEvent (EndpointHandle endpointHandle, uint32_t typeIndex, const unsigned char* eventData)
+    {
+        (void) endpointHandle; (void) typeIndex; (void) eventData;
+
+        if (endpointHandle == 1)
+        {
+            float value;
+            memcpy (&value, eventData, 4);
+            eventData += 4;
+            return addEvent_freq (value);
+        }
+
+        if (endpointHandle == 11)
+        {
+            float value;
+            memcpy (&value, eventData, 4);
+            eventData += 4;
+            return addEvent_gate (value);
+        }
+    }
+
+    void setValue (EndpointHandle endpointHandle, const void* value, int32_t frames)
+    {
+        (void) endpointHandle; (void) value; (void) frames;
+    }
+
+    void setInputFrames (EndpointHandle endpointHandle, const void* frameData, uint32_t numFrames, uint32_t numTrailingFramesToClear)
+    {
+        (void) endpointHandle; (void) frameData; (void) numFrames; (void) numTrailingFramesToClear;
+    }
+
+    //==============================================================================
+    // Rendering state values
+    int32_t initSessionID;
+    double initFrequency;
+    HelloReverb_State state = {};
+    HelloReverb_IO io = {};
+
+    //==============================================================================
+    void _sendEvent_freq (HelloReverb_State& _state, float value) noexcept
+    {
+        _HelloReverb__freq (_state._state, value);
+    }
+
+    void _HelloReverb__freq (_HelloReverb_State& _state, float value) noexcept
+    {
+        faust__voice__freq (_state.Clarinet, value);
+    }
+
+    void faust__voice__freq (faust_voice_1_State& _state, float val) noexcept
+    {
+        _state.fUpdated = (_state.fUpdated ? true : (_state.fHslider2 != val));
+        _state.fHslider2 = val;
+    }
+
+    void _sendEvent_gate (HelloReverb_State& _state, float value) noexcept
+    {
+        _HelloReverb__gate (_state._state, value);
+    }
+
+    void _HelloReverb__gate (_HelloReverb_State& _state, float value) noexcept
+    {
+        faust__voice__gate (_state.Clarinet, value);
+    }
+
+    void faust__voice__gate (faust_voice_1_State& _state, float val) noexcept
+    {
+        _state.fUpdated = (_state.fUpdated ? true : (_state.fButton0 != val));
+        _state.fButton0 = val;
+    }
+
+    void _initialise (HelloReverb_State& _state, int32_t& processorID, int32_t sessionID, double frequency) noexcept
+    {
+        _HelloReverb___initialise (_state._state, processorID, sessionID, frequency);
+    }
+
+    void _HelloReverb___initialise (_HelloReverb_State& _state, int32_t& processorID, int32_t sessionID, double frequency) noexcept
+    {
+        _sessionID = sessionID;
+        _frequency = frequency;
+        HelloWorld___initialise (_state.Hello, processorID, sessionID, frequency);
+        faust__reverb___initialise (_state.Reverb, processorID, sessionID, frequency);
+        faust__echo___initialise (_state.Echo, processorID, sessionID, frequency);
+        faust__voice___initialise (_state.Clarinet, processorID, sessionID, frequency);
+    }
+
+    void HelloWorld___initialise (_HelloWorld_1_State& _state, int32_t& processorID, int32_t sessionID, double frequency) noexcept
+    {
+        _sessionID = sessionID;
+        _frequency = frequency;
+        _state.framesPerQuarterNote = static_cast<int32_t> ((1.0 * _frequency) / static_cast<double> (7));
+    }
+
+    void faust__reverb___initialise (faust_reverb_1_State& _state, int32_t& processorID, int32_t sessionID, double frequency) noexcept
+    {
+        _sessionID = sessionID;
+        _frequency = frequency;
+        faust__reverb__init (_state);
+    }
+
+    void faust__reverb__init (faust_reverb_1_State& _state) noexcept
+    {
+        int32_t  sample_rate;
+
+        sample_rate = static_cast<int32_t> (1.0 * _frequency);
+        faust__reverb__instanceInit (_state, sample_rate);
+    }
+
+    void faust__reverb__instanceInit (faust_reverb_1_State& _state, int32_t sample_rate) noexcept
+    {
+        faust__reverb__classInit (sample_rate);
+        faust__reverb__instanceConstants (_state, sample_rate);
+        faust__reverb__instanceResetUserInterface (_state);
+        faust__reverb__instanceClear (_state);
+    }
+
+    void faust__reverb__classInit (int32_t sample_rate) noexcept
+    {
+    }
+
+    void faust__reverb__instanceConstants (faust_reverb_1_State& _state, int32_t sample_rate) noexcept
+    {
+        _state.fSampleRate = sample_rate;
+        _state.fConst0 = intrinsics::min (192000.0f, intrinsics::max (1.0f, static_cast<float> (_state.fSampleRate)));
+        _state.fConst1 = (44.1f / _state.fConst0);
+        _state.fConst2 = (1.0f - _state.fConst1);
+        _state.fConst3 = (6.2831855f / _state.fConst0);
+        _state.fConst4 = intrinsics::floor ((0.219991f * _state.fConst0) + 0.5f);
+        _state.fConst5 = (6.9077554f * (_state.fConst4 / _state.fConst0));
+        _state.fConst6 = (3.1415927f / _state.fConst0);
+        _state.fConst7 = intrinsics::floor ((0.019123f * _state.fConst0) + 0.5f);
+        _state.iConst8 = static_cast<int32_t> (intrinsics::min (16384.0f, intrinsics::max (0.0f, _state.fConst4 - _state.fConst7)));
+        _state.fConst9 = (0.001f * _state.fConst0);
+        _state.iConst10 = static_cast<int32_t> (intrinsics::min (1024.0f, intrinsics::max (0.0f, _state.fConst7 + -1.0f)));
+        _state.fConst11 = intrinsics::floor ((0.256891f * _state.fConst0) + 0.5f);
+        _state.fConst12 = (6.9077554f * (_state.fConst11 / _state.fConst0));
+        _state.fConst13 = intrinsics::floor ((0.027333f * _state.fConst0) + 0.5f);
+        _state.iConst14 = static_cast<int32_t> (intrinsics::min (16384.0f, intrinsics::max (0.0f, _state.fConst11 - _state.fConst13)));
+        _state.iConst15 = static_cast<int32_t> (intrinsics::min (2048.0f, intrinsics::max (0.0f, _state.fConst13 + -1.0f)));
+        _state.fConst16 = intrinsics::floor ((0.192303f * _state.fConst0) + 0.5f);
+        _state.fConst17 = (6.9077554f * (_state.fConst16 / _state.fConst0));
+        _state.fConst18 = intrinsics::floor ((0.029291f * _state.fConst0) + 0.5f);
+        _state.iConst19 = static_cast<int32_t> (intrinsics::min (8192.0f, intrinsics::max (0.0f, _state.fConst16 - _state.fConst18)));
+        _state.iConst20 = static_cast<int32_t> (intrinsics::min (2048.0f, intrinsics::max (0.0f, _state.fConst18 + -1.0f)));
+        _state.fConst21 = intrinsics::floor ((0.210389f * _state.fConst0) + 0.5f);
+        _state.fConst22 = (6.9077554f * (_state.fConst21 / _state.fConst0));
+        _state.fConst23 = intrinsics::floor ((0.024421f * _state.fConst0) + 0.5f);
+        _state.iConst24 = static_cast<int32_t> (intrinsics::min (16384.0f, intrinsics::max (0.0f, _state.fConst21 - _state.fConst23)));
+        _state.iConst25 = static_cast<int32_t> (intrinsics::min (2048.0f, intrinsics::max (0.0f, _state.fConst23 + -1.0f)));
+        _state.fConst26 = intrinsics::floor ((0.125f * _state.fConst0) + 0.5f);
+        _state.fConst27 = (6.9077554f * (_state.fConst26 / _state.fConst0));
+        _state.fConst28 = intrinsics::floor ((0.013458f * _state.fConst0) + 0.5f);
+        _state.iConst29 = static_cast<int32_t> (intrinsics::min (8192.0f, intrinsics::max (0.0f, _state.fConst26 - _state.fConst28)));
+        _state.iConst30 = static_cast<int32_t> (intrinsics::min (1024.0f, intrinsics::max (0.0f, _state.fConst28 + -1.0f)));
+        _state.fConst31 = intrinsics::floor ((0.127837f * _state.fConst0) + 0.5f);
+        _state.fConst32 = (6.9077554f * (_state.fConst31 / _state.fConst0));
+        _state.fConst33 = intrinsics::floor ((0.031604f * _state.fConst0) + 0.5f);
+        _state.iConst34 = static_cast<int32_t> (intrinsics::min (8192.0f, intrinsics::max (0.0f, _state.fConst31 - _state.fConst33)));
+        _state.iConst35 = static_cast<int32_t> (intrinsics::min (2048.0f, intrinsics::max (0.0f, _state.fConst33 + -1.0f)));
+        _state.fConst36 = intrinsics::floor ((0.174713f * _state.fConst0) + 0.5f);
+        _state.fConst37 = (6.9077554f * (_state.fConst36 / _state.fConst0));
+        _state.fConst38 = intrinsics::floor ((0.022904f * _state.fConst0) + 0.5f);
+        _state.iConst39 = static_cast<int32_t> (intrinsics::min (8192.0f, intrinsics::max (0.0f, _state.fConst36 - _state.fConst38)));
+        _state.iConst40 = static_cast<int32_t> (intrinsics::min (2048.0f, intrinsics::max (0.0f, _state.fConst38 + -1.0f)));
+        _state.fConst41 = intrinsics::floor ((0.153129f * _state.fConst0) + 0.5f);
+        _state.fConst42 = (6.9077554f * (_state.fConst41 / _state.fConst0));
+        _state.fConst43 = intrinsics::floor ((0.020346f * _state.fConst0) + 0.5f);
+        _state.iConst44 = static_cast<int32_t> (intrinsics::min (8192.0f, intrinsics::max (0.0f, _state.fConst41 - _state.fConst43)));
+        _state.iConst45 = static_cast<int32_t> (intrinsics::min (1024.0f, intrinsics::max (0.0f, _state.fConst43 + -1.0f)));
+    }
+
+    float std__intrinsics__min (float v1, float v2) noexcept
+    {
+        {
+            return (v1 < v2) ? v1 : v2;
+        }
+    }
+
+    float std__intrinsics__max (float v1, float v2) noexcept
+    {
+        {
+            return (v1 > v2) ? v1 : v2;
+        }
+    }
+
+    float std__intrinsics__floor (float n) noexcept
+    {
+        float  rounded;
+
+        rounded = static_cast<float> (static_cast<int64_t> (n));
+        if (rounded == n)
+        {
+            return n;
+        }
+        if (n >= static_cast<float> (0))
+        {
+            return rounded;
+        }
+        return rounded - static_cast<float> (1);
+    }
+
+    void faust__reverb__instanceResetUserInterface (faust_reverb_1_State& _state) noexcept
+    {
+        _state.fUpdated = true;
+        _state.fVslider0 = -20.0f;
+        _state.fVslider1 = 0.0f;
+        _state.fVslider2 = 315.0f;
+        _state.fVslider3 = 0.0f;
+        _state.fVslider4 = 2.0f;
+        _state.fVslider5 = 6000.0f;
+        _state.fVslider6 = 3.0f;
+        _state.fVslider7 = 200.0f;
+        _state.fVslider8 = 60.0f;
+        _state.fVslider9 = 1500.0f;
+        _state.fVslider10 = 0.0f;
+    }
+
+    void faust__reverb__instanceClear (faust_reverb_1_State& _state) noexcept
+    {
+        int32_t  l0;
+        int32_t  l1;
+        int32_t  l2;
+        int32_t  l3;
+        int32_t  l4;
+        int32_t  l5;
+        int32_t  l6;
+        int32_t  l7;
+        int32_t  l8;
+        int32_t  l9;
+        int32_t  l10;
+        int32_t  l11;
+        int32_t  l12;
+        int32_t  l13;
+        int32_t  l14;
+        int32_t  l15;
+        int32_t  l16;
+        int32_t  l17;
+        int32_t  l18;
+        int32_t  l19;
+        int32_t  l20;
+        int32_t  l21;
+        int32_t  l22;
+        int32_t  l23;
+        int32_t  l24;
+        int32_t  l25;
+        int32_t  l26;
+        int32_t  l27;
+        int32_t  l28;
+        int32_t  l29;
+        int32_t  l30;
+        int32_t  l31;
+        int32_t  l32;
+        int32_t  l33;
+        int32_t  l34;
+        int32_t  l35;
+        int32_t  l36;
+        int32_t  l37;
+        int32_t  l38;
+        int32_t  l39;
+        int32_t  l40;
+        int32_t  l41;
+        int32_t  l42;
+        int32_t  l43;
+        int32_t  l44;
+        int32_t  l45;
+        int32_t  l46;
+        int32_t  l47;
+        int32_t  l48;
+        int32_t  l49;
+        int32_t  l50;
+        int32_t  l51;
+        int32_t  l52;
+        int32_t  l53;
+        int32_t  l54;
+        int32_t  l55;
+
+        {
+            l0 = 0;
+            for (;;)
+            {
+                if  (! (l0 < 2))
+                {
+                    break;
+                }
+                _state.fRec0[l0 & 1] = 0.0f;
+                {
+                    l0 = (l0 + 1);
+                }
+            }
+        }
+        _state.IOTA0 = 0;
+        {
+            l1 = 0;
+            for (;;)
+            {
+                if  (! (l1 < 16384))
+                {
+                    break;
+                }
+                _state.fVec0[l1 & 16383] = 0.0f;
+                {
+                    l1 = (l1 + 1);
+                }
+            }
+        }
+        {
+            l2 = 0;
+            for (;;)
+            {
+                if  (! (l2 < 2))
+                {
+                    break;
+                }
+                _state.fRec1[l2 & 1] = 0.0f;
+                {
+                    l2 = (l2 + 1);
+                }
+            }
+        }
+        {
+            l3 = 0;
+            for (;;)
+            {
+                if  (! (l3 < 2))
+                {
+                    break;
+                }
+                _state.fRec15[l3 & 1] = 0.0f;
+                {
+                    l3 = (l3 + 1);
+                }
+            }
+        }
+        {
+            l4 = 0;
+            for (;;)
+            {
+                if  (! (l4 < 2))
+                {
+                    break;
+                }
+                _state.fRec14[l4 & 1] = 0.0f;
+                {
+                    l4 = (l4 + 1);
+                }
+            }
+        }
+        {
+            l5 = 0;
+            for (;;)
+            {
+                if  (! (l5 < 32768))
+                {
+                    break;
+                }
+                _state.fVec1[l5 & 32767] = 0.0f;
+                {
+                    l5 = (l5 + 1);
+                }
+            }
+        }
+        {
+            l6 = 0;
+            for (;;)
+            {
+                if  (! (l6 < 16384))
+                {
+                    break;
+                }
+                _state.fVec2[l6 & 16383] = 0.0f;
+                {
+                    l6 = (l6 + 1);
+                }
+            }
+        }
+        {
+            l7 = 0;
+            for (;;)
+            {
+                if  (! (l7 < 2048))
+                {
+                    break;
+                }
+                _state.fVec3[l7 & 2047] = 0.0f;
+                {
+                    l7 = (l7 + 1);
+                }
+            }
+        }
+        {
+            l8 = 0;
+            for (;;)
+            {
+                if  (! (l8 < 2))
+                {
+                    break;
+                }
+                _state.fRec12[l8 & 1] = 0.0f;
+                {
+                    l8 = (l8 + 1);
+                }
+            }
+        }
+        {
+            l9 = 0;
+            for (;;)
+            {
+                if  (! (l9 < 2))
+                {
+                    break;
+                }
+                _state.fRec19[l9 & 1] = 0.0f;
+                {
+                    l9 = (l9 + 1);
+                }
+            }
+        }
+        {
+            l10 = 0;
+            for (;;)
+            {
+                if  (! (l10 < 2))
+                {
+                    break;
+                }
+                _state.fRec18[l10 & 1] = 0.0f;
+                {
+                    l10 = (l10 + 1);
+                }
+            }
+        }
+        {
+            l11 = 0;
+            for (;;)
+            {
+                if  (! (l11 < 32768))
+                {
+                    break;
+                }
+                _state.fVec4[l11 & 32767] = 0.0f;
+                {
+                    l11 = (l11 + 1);
+                }
+            }
+        }
+        {
+            l12 = 0;
+            for (;;)
+            {
+                if  (! (l12 < 4096))
+                {
+                    break;
+                }
+                _state.fVec5[l12 & 4095] = 0.0f;
+                {
+                    l12 = (l12 + 1);
+                }
+            }
+        }
+        {
+            l13 = 0;
+            for (;;)
+            {
+                if  (! (l13 < 2))
+                {
+                    break;
+                }
+                _state.fRec16[l13 & 1] = 0.0f;
+                {
+                    l13 = (l13 + 1);
+                }
+            }
+        }
+        {
+            l14 = 0;
+            for (;;)
+            {
+                if  (! (l14 < 2))
+                {
+                    break;
+                }
+                _state.fRec23[l14 & 1] = 0.0f;
+                {
+                    l14 = (l14 + 1);
+                }
+            }
+        }
+        {
+            l15 = 0;
+            for (;;)
+            {
+                if  (! (l15 < 2))
+                {
+                    break;
+                }
+                _state.fRec22[l15 & 1] = 0.0f;
+                {
+                    l15 = (l15 + 1);
+                }
+            }
+        }
+        {
+            l16 = 0;
+            for (;;)
+            {
+                if  (! (l16 < 16384))
+                {
+                    break;
+                }
+                _state.fVec6[l16 & 16383] = 0.0f;
+                {
+                    l16 = (l16 + 1);
+                }
+            }
+        }
+        {
+            l17 = 0;
+            for (;;)
+            {
+                if  (! (l17 < 4096))
+                {
+                    break;
+                }
+                _state.fVec7[l17 & 4095] = 0.0f;
+                {
+                    l17 = (l17 + 1);
+                }
+            }
+        }
+        {
+            l18 = 0;
+            for (;;)
+            {
+                if  (! (l18 < 2))
+                {
+                    break;
+                }
+                _state.fRec20[l18 & 1] = 0.0f;
+                {
+                    l18 = (l18 + 1);
+                }
+            }
+        }
+        {
+            l19 = 0;
+            for (;;)
+            {
+                if  (! (l19 < 2))
+                {
+                    break;
+                }
+                _state.fRec27[l19 & 1] = 0.0f;
+                {
+                    l19 = (l19 + 1);
+                }
+            }
+        }
+        {
+            l20 = 0;
+            for (;;)
+            {
+                if  (! (l20 < 2))
+                {
+                    break;
+                }
+                _state.fRec26[l20 & 1] = 0.0f;
+                {
+                    l20 = (l20 + 1);
+                }
+            }
+        }
+        {
+            l21 = 0;
+            for (;;)
+            {
+                if  (! (l21 < 32768))
+                {
+                    break;
+                }
+                _state.fVec8[l21 & 32767] = 0.0f;
+                {
+                    l21 = (l21 + 1);
+                }
+            }
+        }
+        {
+            l22 = 0;
+            for (;;)
+            {
+                if  (! (l22 < 4096))
+                {
+                    break;
+                }
+                _state.fVec9[l22 & 4095] = 0.0f;
+                {
+                    l22 = (l22 + 1);
+                }
+            }
+        }
+        {
+            l23 = 0;
+            for (;;)
+            {
+                if  (! (l23 < 2))
+                {
+                    break;
+                }
+                _state.fRec24[l23 & 1] = 0.0f;
+                {
+                    l23 = (l23 + 1);
+                }
+            }
+        }
+        {
+            l24 = 0;
+            for (;;)
+            {
+                if  (! (l24 < 2))
+                {
+                    break;
+                }
+                _state.fRec31[l24 & 1] = 0.0f;
+                {
+                    l24 = (l24 + 1);
+                }
+            }
+        }
+        {
+            l25 = 0;
+            for (;;)
+            {
+                if  (! (l25 < 2))
+                {
+                    break;
+                }
+                _state.fRec30[l25 & 1] = 0.0f;
+                {
+                    l25 = (l25 + 1);
+                }
+            }
+        }
+        {
+            l26 = 0;
+            for (;;)
+            {
+                if  (! (l26 < 16384))
+                {
+                    break;
+                }
+                _state.fVec10[l26 & 16383] = 0.0f;
+                {
+                    l26 = (l26 + 1);
+                }
+            }
+        }
+        {
+            l27 = 0;
+            for (;;)
+            {
+                if  (! (l27 < 2048))
+                {
+                    break;
+                }
+                _state.fVec11[l27 & 2047] = 0.0f;
+                {
+                    l27 = (l27 + 1);
+                }
+            }
+        }
+        {
+            l28 = 0;
+            for (;;)
+            {
+                if  (! (l28 < 2))
+                {
+                    break;
+                }
+                _state.fRec28[l28 & 1] = 0.0f;
+                {
+                    l28 = (l28 + 1);
+                }
+            }
+        }
+        {
+            l29 = 0;
+            for (;;)
+            {
+                if  (! (l29 < 2))
+                {
+                    break;
+                }
+                _state.fRec35[l29 & 1] = 0.0f;
+                {
+                    l29 = (l29 + 1);
+                }
+            }
+        }
+        {
+            l30 = 0;
+            for (;;)
+            {
+                if  (! (l30 < 2))
+                {
+                    break;
+                }
+                _state.fRec34[l30 & 1] = 0.0f;
+                {
+                    l30 = (l30 + 1);
+                }
+            }
+        }
+        {
+            l31 = 0;
+            for (;;)
+            {
+                if  (! (l31 < 16384))
+                {
+                    break;
+                }
+                _state.fVec12[l31 & 16383] = 0.0f;
+                {
+                    l31 = (l31 + 1);
+                }
+            }
+        }
+        {
+            l32 = 0;
+            for (;;)
+            {
+                if  (! (l32 < 4096))
+                {
+                    break;
+                }
+                _state.fVec13[l32 & 4095] = 0.0f;
+                {
+                    l32 = (l32 + 1);
+                }
+            }
+        }
+        {
+            l33 = 0;
+            for (;;)
+            {
+                if  (! (l33 < 2))
+                {
+                    break;
+                }
+                _state.fRec32[l33 & 1] = 0.0f;
+                {
+                    l33 = (l33 + 1);
+                }
+            }
+        }
+        {
+            l34 = 0;
+            for (;;)
+            {
+                if  (! (l34 < 2))
+                {
+                    break;
+                }
+                _state.fRec39[l34 & 1] = 0.0f;
+                {
+                    l34 = (l34 + 1);
+                }
+            }
+        }
+        {
+            l35 = 0;
+            for (;;)
+            {
+                if  (! (l35 < 2))
+                {
+                    break;
+                }
+                _state.fRec38[l35 & 1] = 0.0f;
+                {
+                    l35 = (l35 + 1);
+                }
+            }
+        }
+        {
+            l36 = 0;
+            for (;;)
+            {
+                if  (! (l36 < 16384))
+                {
+                    break;
+                }
+                _state.fVec14[l36 & 16383] = 0.0f;
+                {
+                    l36 = (l36 + 1);
+                }
+            }
+        }
+        {
+            l37 = 0;
+            for (;;)
+            {
+                if  (! (l37 < 4096))
+                {
+                    break;
+                }
+                _state.fVec15[l37 & 4095] = 0.0f;
+                {
+                    l37 = (l37 + 1);
+                }
+            }
+        }
+        {
+            l38 = 0;
+            for (;;)
+            {
+                if  (! (l38 < 2))
+                {
+                    break;
+                }
+                _state.fRec36[l38 & 1] = 0.0f;
+                {
+                    l38 = (l38 + 1);
+                }
+            }
+        }
+        {
+            l39 = 0;
+            for (;;)
+            {
+                if  (! (l39 < 2))
+                {
+                    break;
+                }
+                _state.fRec43[l39 & 1] = 0.0f;
+                {
+                    l39 = (l39 + 1);
+                }
+            }
+        }
+        {
+            l40 = 0;
+            for (;;)
+            {
+                if  (! (l40 < 2))
+                {
+                    break;
+                }
+                _state.fRec42[l40 & 1] = 0.0f;
+                {
+                    l40 = (l40 + 1);
+                }
+            }
+        }
+        {
+            l41 = 0;
+            for (;;)
+            {
+                if  (! (l41 < 16384))
+                {
+                    break;
+                }
+                _state.fVec16[l41 & 16383] = 0.0f;
+                {
+                    l41 = (l41 + 1);
+                }
+            }
+        }
+        {
+            l42 = 0;
+            for (;;)
+            {
+                if  (! (l42 < 2048))
+                {
+                    break;
+                }
+                _state.fVec17[l42 & 2047] = 0.0f;
+                {
+                    l42 = (l42 + 1);
+                }
+            }
+        }
+        {
+            l43 = 0;
+            for (;;)
+            {
+                if  (! (l43 < 2))
+                {
+                    break;
+                }
+                _state.fRec40[l43 & 1] = 0.0f;
+                {
+                    l43 = (l43 + 1);
+                }
+            }
+        }
+        {
+            l44 = 0;
+            for (;;)
+            {
+                if  (! (l44 < 3))
+                {
+                    break;
+                }
+                _state.fRec4[std__intrinsics___wrap_3 (l44)] = 0.0f;
+                {
+                    l44 = (l44 + 1);
+                }
+            }
+        }
+        {
+            l45 = 0;
+            for (;;)
+            {
+                if  (! (l45 < 3))
+                {
+                    break;
+                }
+                _state.fRec5[std__intrinsics___wrap_3 (l45)] = 0.0f;
+                {
+                    l45 = (l45 + 1);
+                }
+            }
+        }
+        {
+            l46 = 0;
+            for (;;)
+            {
+                if  (! (l46 < 3))
+                {
+                    break;
+                }
+                _state.fRec6[std__intrinsics___wrap_3 (l46)] = 0.0f;
+                {
+                    l46 = (l46 + 1);
+                }
+            }
+        }
+        {
+            l47 = 0;
+            for (;;)
+            {
+                if  (! (l47 < 3))
+                {
+                    break;
+                }
+                _state.fRec7[std__intrinsics___wrap_3 (l47)] = 0.0f;
+                {
+                    l47 = (l47 + 1);
+                }
+            }
+        }
+        {
+            l48 = 0;
+            for (;;)
+            {
+                if  (! (l48 < 3))
+                {
+                    break;
+                }
+                _state.fRec8[std__intrinsics___wrap_3 (l48)] = 0.0f;
+                {
+                    l48 = (l48 + 1);
+                }
+            }
+        }
+        {
+            l49 = 0;
+            for (;;)
+            {
+                if  (! (l49 < 3))
+                {
+                    break;
+                }
+                _state.fRec9[std__intrinsics___wrap_3 (l49)] = 0.0f;
+                {
+                    l49 = (l49 + 1);
+                }
+            }
+        }
+        {
+            l50 = 0;
+            for (;;)
+            {
+                if  (! (l50 < 3))
+                {
+                    break;
+                }
+                _state.fRec10[std__intrinsics___wrap_3 (l50)] = 0.0f;
+                {
+                    l50 = (l50 + 1);
+                }
+            }
+        }
+        {
+            l51 = 0;
+            for (;;)
+            {
+                if  (! (l51 < 3))
+                {
+                    break;
+                }
+                _state.fRec11[std__intrinsics___wrap_3 (l51)] = 0.0f;
+                {
+                    l51 = (l51 + 1);
+                }
+            }
+        }
+        {
+            l52 = 0;
+            for (;;)
+            {
+                if  (! (l52 < 3))
+                {
+                    break;
+                }
+                _state.fRec3[std__intrinsics___wrap_3 (l52)] = 0.0f;
+                {
+                    l52 = (l52 + 1);
+                }
+            }
+        }
+        {
+            l53 = 0;
+            for (;;)
+            {
+                if  (! (l53 < 3))
+                {
+                    break;
+                }
+                _state.fRec2[std__intrinsics___wrap_3 (l53)] = 0.0f;
+                {
+                    l53 = (l53 + 1);
+                }
+            }
+        }
+        {
+            l54 = 0;
+            for (;;)
+            {
+                if  (! (l54 < 3))
+                {
+                    break;
+                }
+                _state.fRec45[std__intrinsics___wrap_3 (l54)] = 0.0f;
+                {
+                    l54 = (l54 + 1);
+                }
+            }
+        }
+        {
+            l55 = 0;
+            for (;;)
+            {
+                if  (! (l55 < 3))
+                {
+                    break;
+                }
+                _state.fRec44[std__intrinsics___wrap_3 (l55)] = 0.0f;
+                {
+                    l55 = (l55 + 1);
+                }
+            }
+        }
+    }
+
+    int32_t std__intrinsics___wrap_3 (int32_t n) noexcept
+    {
+        int32_t  x;
+
+        x = intrinsics::modulo (n, 3);
+        return (x < 0) ? (x + 3) : x;
+    }
+
+    void faust__echo___initialise (faust_echo_1_State& _state, int32_t& processorID, int32_t sessionID, double frequency) noexcept
+    {
+        _sessionID = sessionID;
+        _frequency = frequency;
+        faust__echo__init (_state);
+    }
+
+    void faust__echo__init (faust_echo_1_State& _state) noexcept
+    {
+        int32_t  sample_rate;
+
+        sample_rate = static_cast<int32_t> (1.0 * _frequency);
+        faust__echo__instanceInit (_state, sample_rate);
+    }
+
+    void faust__echo__instanceInit (faust_echo_1_State& _state, int32_t sample_rate) noexcept
+    {
+        faust__echo__classInit (sample_rate);
+        faust__echo__instanceConstants (_state, sample_rate);
+        faust__echo__instanceResetUserInterface (_state);
+        faust__echo__instanceClear (_state);
+    }
+
+    void faust__echo__classInit (int32_t sample_rate) noexcept
+    {
+    }
+
+    void faust__echo__instanceConstants (faust_echo_1_State& _state, int32_t sample_rate) noexcept
+    {
+        _state.fSampleRate = sample_rate;
+        _state.fConst0 = intrinsics::min (192000.0f, intrinsics::max (1.0f, static_cast<float> (_state.fSampleRate)));
+    }
+
+    void faust__echo__instanceResetUserInterface (faust_echo_1_State& _state) noexcept
+    {
+        _state.fUpdated = true;
+        _state.fVslider0 = 2.7f;
+    }
+
+    void faust__echo__instanceClear (faust_echo_1_State& _state) noexcept
+    {
+        int32_t  l0;
+        int32_t  l1;
+
+        _state.IOTA0 = 0;
+        {
+            l0 = 0;
+            for (;;)
+            {
+                if  (! (l0 < 0x200000))
+                {
+                    break;
+                }
+                _state.fRec0[l0 & 0x1fffff] = 0.0f;
+                {
+                    l0 = (l0 + 1);
+                }
+            }
+        }
+        {
+            l1 = 0;
+            for (;;)
+            {
+                if  (! (l1 < 0x200000))
+                {
+                    break;
+                }
+                _state.fRec1[l1 & 0x1fffff] = 0.0f;
+                {
+                    l1 = (l1 + 1);
+                }
+            }
+        }
+    }
+
+    void faust__voice___initialise (faust_voice_1_State& _state, int32_t& processorID, int32_t sessionID, double frequency) noexcept
+    {
+        _sessionID = sessionID;
+        _frequency = frequency;
+        faust__voice__init (_state);
+    }
+
+    void faust__voice__init (faust_voice_1_State& _state) noexcept
+    {
+        int32_t  sample_rate;
+
+        sample_rate = static_cast<int32_t> (1.0 * _frequency);
+        faust__voice__instanceInit (_state, sample_rate);
+    }
+
+    void faust__voice__instanceInit (faust_voice_1_State& _state, int32_t sample_rate) noexcept
+    {
+        faust__voice__classInit (_state, sample_rate);
+        faust__voice__instanceConstants (_state, sample_rate);
+        faust__voice__instanceResetUserInterface (_state);
+        faust__voice__instanceClear (_state);
+    }
+
+    void faust__voice__classInit (faust_voice_1_State& _state, int32_t sample_rate) noexcept
+    {
+        faust_voice_1_voiceSIG0  sig0;
+
+        sig0 = faust__voice__newvoiceSIG0();
+        faust__voice__instanceInitvoiceSIG0 (sig0, sample_rate);
+        faust__voice__fillvoiceSIG0_65536 (sig0, 0x10000, _state.ftbl0voiceSIG0);
+        faust__voice__deletevoiceSIG0 (sig0);
+    }
+
+    faust_voice_1_voiceSIG0 faust__voice__newvoiceSIG0() noexcept
+    {
+        faust_voice_1_voiceSIG0  obj;
+
+        obj = faust_voice_1_voiceSIG0 {};
+        return obj;
+    }
+
+    void faust__voice__instanceInitvoiceSIG0 (faust_voice_1_voiceSIG0& this_, int32_t sample_rate) noexcept
+    {
+        int32_t  l6;
+        int32_t  l7;
+
+        {
+            l6 = 0;
+            for (;;)
+            {
+                if  (! (l6 < 2))
+                {
+                    break;
+                }
+                this_.iVec2[l6 & 1] = 0;
+                {
+                    l6 = (l6 + 1);
+                }
+            }
+        }
+        {
+            l7 = 0;
+            for (;;)
+            {
+                if  (! (l7 < 2))
+                {
+                    break;
+                }
+                this_.iRec15[l7 & 1] = 0;
+                {
+                    l7 = (l7 + 1);
+                }
+            }
+        }
+    }
+
+    void faust__voice__fillvoiceSIG0_65536 (faust_voice_1_voiceSIG0& this_, int32_t count, Array<float, 65536>& table) noexcept
+    {
+        int32_t  i1;
+
+        {
+            i1 = 0;
+            for (;;)
+            {
+                if  (! (i1 < count))
+                {
+                    break;
+                }
+                this_.iVec2[0] = 1;
+                this_.iRec15[0] = intrinsics::modulo (this_.iVec2[1] + this_.iRec15[1], 0x10000);
+                table[i1 & 65535] = intrinsics::sin (0.0000958738f * static_cast<float> (this_.iRec15[0]));
+                this_.iVec2[1] = this_.iVec2[0];
+                this_.iRec15[1] = this_.iRec15[0];
+                {
+                    i1 = (i1 + 1);
+                }
+            }
+        }
+    }
+
+    float std__intrinsics__sin (float n) noexcept
+    {
+        {
+            return 0.0f;
+        }
+    }
+
+    void faust__voice__deletevoiceSIG0 (faust_voice_1_voiceSIG0& this_) noexcept
+    {
+    }
+
+    void faust__voice__instanceConstants (faust_voice_1_State& _state, int32_t sample_rate) noexcept
+    {
+        _state.fSampleRate = sample_rate;
+        _state.fConst0 = intrinsics::min (192000.0f, intrinsics::max (1.0f, static_cast<float> (_state.fSampleRate)));
+        _state.fConst1 = (0.0014705883f * _state.fConst0);
+        _state.fConst2 = (1.0f / _state.fConst0);
+        _state.fConst3 = intrinsics::tan (6283.1855f / _state.fConst0);
+        _state.fConst4 = (1.0f / _state.fConst3);
+        _state.fConst5 = (((_state.fConst4 + 1.4142135f) / _state.fConst3) + 1.0f);
+        _state.fConst6 = (0.05f / _state.fConst5);
+        _state.fConst7 = (1.0f / _state.fConst5);
+        _state.fConst8 = (((_state.fConst4 + -1.4142135f) / _state.fConst3) + 1.0f);
+        _state.fConst9 = (2.0f * (1.0f - (1.0f / intrinsics::pow (_state.fConst3, 2.0f))));
+        _state.fConst10 = (0.00882353f * _state.fConst0);
+    }
+
+    float std__intrinsics__tan (float n) noexcept
+    {
+        {
+            return intrinsics::sin (n) / intrinsics::cos (n);
+        }
+    }
+
+    float std__intrinsics__cos (float n) noexcept
+    {
+        {
+            return 0.0f;
+        }
+    }
+
+    float std__intrinsics__pow (float a, float b) noexcept
+    {
+        {
+            return 0.0f;
+        }
+    }
+
+    void faust__voice__instanceResetUserInterface (faust_voice_1_State& _state) noexcept
+    {
+        _state.fUpdated = true;
+        _state.fHslider0 = 0.5f;
+        _state.fHslider1 = 0.5f;
+        _state.fHslider2 = 440.0f;
+        _state.fHslider3 = 0.0f;
+        _state.fButton0 = 0.0f;
+        _state.fHslider4 = 0.0f;
+        _state.fHslider5 = 0.25f;
+        _state.fHslider6 = 0.6f;
+        _state.fHslider7 = 1.0f;
+        _state.fHslider8 = 5.0f;
+        _state.fHslider9 = 0.5f;
+    }
+
+    void faust__voice__instanceClear (faust_voice_1_State& _state) noexcept
+    {
+        int32_t  l0;
+        int32_t  l1;
+        int32_t  l2;
+        int32_t  l3;
+        int32_t  l4;
+        int32_t  l5;
+        int32_t  l8;
+        int32_t  l9;
+        int32_t  l10;
+        int32_t  l11;
+        int32_t  l12;
+        int32_t  l13;
+        int32_t  l14;
+        int32_t  l15;
+        int32_t  l16;
+
+        {
+            l0 = 0;
+            for (;;)
+            {
+                if  (! (l0 < 2))
+                {
+                    break;
+                }
+                _state.iRec6[l0 & 1] = 0;
+                {
+                    l0 = (l0 + 1);
+                }
+            }
+        }
+        {
+            l1 = 0;
+            for (;;)
+            {
+                if  (! (l1 < 2))
+                {
+                    break;
+                }
+                _state.iVec0[l1 & 1] = 0;
+                {
+                    l1 = (l1 + 1);
+                }
+            }
+        }
+        {
+            l2 = 0;
+            for (;;)
+            {
+                if  (! (l2 < 2))
+                {
+                    break;
+                }
+                _state.fRec12[l2 & 1] = 0.0f;
+                {
+                    l2 = (l2 + 1);
+                }
+            }
+        }
+        {
+            l3 = 0;
+            for (;;)
+            {
+                if  (! (l3 < 2))
+                {
+                    break;
+                }
+                _state.fVec1[l3 & 1] = 0.0f;
+                {
+                    l3 = (l3 + 1);
+                }
+            }
+        }
+        {
+            l4 = 0;
+            for (;;)
+            {
+                if  (! (l4 < 2))
+                {
+                    break;
+                }
+                _state.fRec13[l4 & 1] = 0.0f;
+                {
+                    l4 = (l4 + 1);
+                }
+            }
+        }
+        {
+            l5 = 0;
+            for (;;)
+            {
+                if  (! (l5 < 2))
+                {
+                    break;
+                }
+                _state.fRec14[l5 & 1] = 0.0f;
+                {
+                    l5 = (l5 + 1);
+                }
+            }
+        }
+        {
+            l8 = 0;
+            for (;;)
+            {
+                if  (! (l8 < 2))
+                {
+                    break;
+                }
+                _state.fRec16[l8 & 1] = 0.0f;
+                {
+                    l8 = (l8 + 1);
+                }
+            }
+        }
+        {
+            l9 = 0;
+            for (;;)
+            {
+                if  (! (l9 < 2))
+                {
+                    break;
+                }
+                _state.iRec20[l9 & 1] = 0;
+                {
+                    l9 = (l9 + 1);
+                }
+            }
+        }
+        {
+            l10 = 0;
+            for (;;)
+            {
+                if  (! (l10 < 3))
+                {
+                    break;
+                }
+                _state.fRec19[std__intrinsics___wrap_3 (l10)] = 0.0f;
+                {
+                    l10 = (l10 + 1);
+                }
+            }
+        }
+        {
+            l11 = 0;
+            for (;;)
+            {
+                if  (! (l11 < 2))
+                {
+                    break;
+                }
+                _state.fRec17[l11 & 1] = 0.0f;
+                {
+                    l11 = (l11 + 1);
+                }
+            }
+        }
+        _state.IOTA0 = 0;
+        {
+            l12 = 0;
+            for (;;)
+            {
+                if  (! (l12 < 2048))
+                {
+                    break;
+                }
+                _state.fRec18[l12 & 2047] = 0.0f;
+                {
+                    l12 = (l12 + 1);
+                }
+            }
+        }
+        {
+            l13 = 0;
+            for (;;)
+            {
+                if  (! (l13 < 2))
+                {
+                    break;
+                }
+                _state.fVec3[l13 & 1] = 0.0f;
+                {
+                    l13 = (l13 + 1);
+                }
+            }
+        }
+        {
+            l14 = 0;
+            for (;;)
+            {
+                if  (! (l14 < 2))
+                {
+                    break;
+                }
+                _state.fRec11[l14 & 1] = 0.0f;
+                {
+                    l14 = (l14 + 1);
+                }
+            }
+        }
+        {
+            l15 = 0;
+            for (;;)
+            {
+                if  (! (l15 < 2048))
+                {
+                    break;
+                }
+                _state.fRec2[l15 & 2047] = 0.0f;
+                {
+                    l15 = (l15 + 1);
+                }
+            }
+        }
+        {
+            l16 = 0;
+            for (;;)
+            {
+                if  (! (l16 < 2))
+                {
+                    break;
+                }
+                _state.fRec0[l16 & 1] = 0.0f;
+                {
+                    l16 = (l16 + 1);
+                }
+            }
+        }
+    }
+
+    void _advance (HelloReverb_State& _state, HelloReverb_IO& _io, int32_t _frames) noexcept
+    {
+        _HelloReverb_IO  ioCopy;
+
+        for (;;)
+        {
+            if (_state._currentFrame == _frames)
+            {
+                break;
+            }
+            ioCopy = _HelloReverb_IO {};
+            main (_state._state, ioCopy);
+            _io.out0[_state._currentFrame] = ioCopy.out0;
+            _io.out1[_state._currentFrame] = ioCopy.out1;
+            ++_state._currentFrame;
+        }
+        _state._currentFrame = 0;
+    }
+
+    void main (_HelloReverb_State& _state, _HelloReverb_IO& _io) noexcept
+    {
+        _HelloWorld_1_IO  Hello_io;
+        faust_reverb_1_IO  Reverb_io;
+        faust_reverb_1_IO  Echo_io;
+        faust_voice_1_IO  Clarinet_io;
+
+        Hello_io = _HelloWorld_1_IO {};
+        Reverb_io = faust_reverb_1_IO {};
+        Echo_io = faust_reverb_1_IO {};
+        Clarinet_io = faust_voice_1_IO {};
+        {
+        }
+        HelloWorld__main (_state.Hello, Hello_io);
+        {
+        }
+        faust__voice__main (_state.Clarinet, Clarinet_io);
+        {
+            Reverb_io.input0 = (Reverb_io.input0 + Hello_io.out);
+            Reverb_io.input1 = (Reverb_io.input1 + Hello_io.out);
+            Reverb_io.input0 = (Reverb_io.input0 + Clarinet_io.output0);
+            Reverb_io.input1 = (Reverb_io.input1 + Clarinet_io.output1);
+        }
+        faust__reverb__main (_state.Reverb, Reverb_io);
+        {
+            Echo_io.input0 = (Echo_io.input0 + Reverb_io.output0);
+            Echo_io.input1 = (Echo_io.input1 + Reverb_io.output1);
+        }
+        faust__echo__main (_state.Echo, Echo_io);
+        {
+            _io.out0 = (_io.out0 + Echo_io.output0);
+            _io.out1 = (_io.out1 + Echo_io.output1);
+        }
+    }
+
+    void HelloWorld__main (_HelloWorld_1_State& _state, _HelloWorld_1_IO& _io) noexcept
+    {
+        _HelloWorld_1_Note  this_;
+        int32_t  numFrames;
+        float  frequency;
+
+        switch (_state._resumeIndex)
+        {
+            case 1: goto _branch0_0;
+            case 2: goto _branch0_1;
+            default: break;
+        }
+
+        {
+            _state.i = 0;
+            for (;;)
+            {
+                if (_state.i >= 13)
+                {
+                    break;
+                }
+                {
+                    this_ = melody[_state.i];
+                    numFrames = this_.length * _state.framesPerQuarterNote;
+                    frequency = std__notes__noteToFrequency (this_.pitch);
+                    _state.phaseDelta = static_cast<float> ((static_cast<double> (frequency) * (1.0 / (1.0 * _frequency))) * 6.283185307179586);
+                    {
+                        _state._count = numFrames;
+                        _branch0_0:
+                        {
+                            for (;;)
+                            {
+                                --_state._count;
+                                if (_state._count < 0)
+                                {
+                                    goto _break_0;
+                                }
+                                _io.out = (_io.out + (volume * intrinsics::sin (_state.phase)));
+                                _state.phase = intrinsics::addModulo2Pi (_state.phase, _state.phaseDelta);
+                                _state._resumeIndex = 1;
+                                return;
+                            }
+                        }
+                        _break_0: {}
+                    }
+                }
+                {
+                    ++_state.i;
+                }
+            }
+        }
+        _branch0_1:
+        {
+            _state._resumeIndex = 2;
+        }
+    }
+
+    float std__notes__noteToFrequency (int32_t midiNoteNumber) noexcept
+    {
+        return 440.0f * intrinsics::pow (2.0f, 0.083333336f * static_cast<float> (midiNoteNumber - 69));
+    }
+
+    float std__intrinsics__addModulo2Pi (float startValue, float valueToAdd) noexcept
+    {
+        float  v;
+
+        v = startValue + valueToAdd;
+        if (v < static_cast<float> (0))
+        {
+            return intrinsics::fmod (v, 6.2831855f) + 6.2831855f;
+        }
+        if (v < 6.2831855f)
+        {
+            return v;
+        }
+        if (v < 12.566371f)
+        {
+            return v - 6.2831855f;
+        }
+        return intrinsics::fmod (v, 6.2831855f);
+    }
+
+    float std__intrinsics__fmod (float x, float y) noexcept
+    {
+        return x - (y * static_cast<float> (static_cast<int64_t> (x / y)));
+    }
+
+    void faust__voice__main (faust_voice_1_State& _state, faust_voice_1_IO& _io) noexcept
+    {
+        float  fRec10;
+        float  fTemp0;
+        float  fTemp1;
+        float  fTemp2;
+        float  fTemp3;
+        float  fTemp4;
+        float  fTemp5;
+        float  fTemp6;
+        float  fTemp7;
+        float  fTemp8;
+        float  fTemp9;
+        float  fTemp10;
+        int32_t  iTemp11;
+        int32_t  iTemp12;
+        float  fTemp13;
+        float  fTemp14;
+        int32_t  iTemp15;
+        float  fTemp16;
+        int32_t  iTemp17;
+        float  fTemp18;
+        int32_t  iTemp19;
+        float  fTemp20;
+        int32_t  iTemp21;
+        float  fRec7;
+        float  fRec8;
+        float  fRec9;
+        float  fRec3;
+        float  fRec4;
+        float  fRec5;
+        float  fRec1;
+        float  fTemp22;
+
+        for (;;)
+        {
+            if (_state.fUpdated)
+            {
+                _state.fUpdated = false;
+                faust__voice__control (_state);
+            }
+            _state.iRec6[0] = 0;
+            _state.iVec0[0] = 1;
+            _state.fRec12[0] = ((_state.fSlow2 * _state.fRec11[1]) + (_state.fSlow1 * _state.fRec12[1]));
+            fRec10 = _state.fRec12[0] + static_cast<float> (_state.iRec6[1]);
+            _state.fVec1[0] = _state.fSlow5;
+            fTemp0 = static_cast<float> (static_cast<int32_t> (_state.fSlow5 == _state.fVec1[1]) | _state.iSlow6);
+            _state.fRec13[0] = ((_state.fSlow4 * (1.0f - (0.999f * fTemp0))) + ((0.999f * fTemp0) * _state.fRec13[1]));
+            _state.fRec14[0] = (_state.fSlow11 + (_state.fSlow10 * _state.fRec14[1]));
+            fTemp1 = static_cast<bool> (1 - _state.iVec0[1]) ? 0.0f : (_state.fSlow12 + _state.fRec16[1]);
+            _state.fRec16[0] = (fTemp1 - intrinsics::floor (fTemp1));
+            fTemp2 = _state.ftbl0voiceSIG0[intrinsics::max (0, intrinsics::min (static_cast<int32_t> (65536.0f * _state.fRec16[0]), 65535)) & 65535];
+            fTemp3 = _state.fConst1 * ((_state.fSlow3 / (_state.fRec13[0] * (((_state.fSlow7 * _state.fRec14[0]) * fTemp2) + 1.0f))) + -0.05f);
+            fTemp4 = fTemp3 + -1.499995f;
+            fTemp5 = intrinsics::floor (fTemp4);
+            fTemp6 = fTemp3 + (-4.0f - fTemp5);
+            fTemp7 = fTemp3 + (-3.0f - fTemp5);
+            fTemp8 = fTemp3 + (-2.0f - fTemp5);
+            _state.iRec20[0] = ((0x41c64e6d * _state.iRec20[1]) + 12345);
+            _state.fRec19[0] = ((4.656613e-10f * static_cast<float> (_state.iRec20[0])) - (_state.fConst7 * ((_state.fConst8 * _state.fRec19[2]) + (_state.fConst9 * _state.fRec19[1]))));
+            fTemp9 = _state.fRec14[0] * ((_state.fConst6 * ((_state.fRec19[2] + _state.fRec19[0]) + (2.0f * _state.fRec19[1]))) + 1.0f);
+            fTemp10 = _state.fSlow7 * fTemp2;
+            _state.fRec17[0] = ((fTemp9 + _state.fRec0[1]) + fTemp10);
+            _state.fRec18[(_state.IOTA0 & 2047) & 2047] = ((fTemp10 + fTemp9) - (_state.fRec17[1] * intrinsics::max (-1.0f, intrinsics::min (1.0f, 0.7f - (_state.fSlow13 * _state.fRec17[1])))));
+            iTemp11 = static_cast<int32_t> (fTemp4);
+            iTemp12 = static_cast<int32_t> (intrinsics::min (_state.fConst10, static_cast<float> (intrinsics::max (0, iTemp11)))) + 1;
+            fTemp13 = fTemp3 + (-1.0f - fTemp5);
+            fTemp14 = fTemp3 - fTemp5;
+            iTemp15 = static_cast<int32_t> (intrinsics::min (_state.fConst10, static_cast<float> (intrinsics::max (0, iTemp11 + 1)))) + 1;
+            fTemp16 = fTemp14 * fTemp13;
+            iTemp17 = static_cast<int32_t> (intrinsics::min (_state.fConst10, static_cast<float> (intrinsics::max (0, iTemp11 + 2)))) + 1;
+            fTemp18 = fTemp16 * fTemp8;
+            iTemp19 = static_cast<int32_t> (intrinsics::min (_state.fConst10, static_cast<float> (intrinsics::max (0, iTemp11 + 3)))) + 1;
+            fTemp20 = fTemp18 * fTemp7;
+            iTemp21 = static_cast<int32_t> (intrinsics::min (_state.fConst10, static_cast<float> (intrinsics::max (0, iTemp11 + 4)))) + 1;
+            _state.fVec3[0] = ((fTemp6 * ((fTemp7 * ((fTemp8 * (((0.041666668f * _state.fRec18[((_state.IOTA0 - iTemp12) & 2047) & 2047]) * fTemp13) - ((0.16666667f * fTemp14) * _state.fRec18[((_state.IOTA0 - iTemp15) & 2047) & 2047]))) + ((0.25f * fTemp16) * _state.fRec18[((_state.IOTA0 - iTemp17) & 2047) & 2047]))) - ((0.16666667f * fTemp18) * _state.fRec18[((_state.IOTA0 - iTemp19) & 2047) & 2047]))) + ((0.041666668f * fTemp20) * _state.fRec18[((_state.IOTA0 - iTemp21) & 2047) & 2047]));
+            _state.fRec11[0] = _state.fVec3[1];
+            fRec7 = fRec10;
+            fRec8 = _state.fRec11[0];
+            fRec9 = _state.fRec11[0];
+            _state.fRec2[(_state.IOTA0 & 2047) & 2047] = fRec7;
+            fRec3 = (fTemp6 * ((fTemp7 * ((fTemp8 * (((0.041666668f * fTemp13) * _state.fRec2[((_state.IOTA0 - iTemp12) & 2047) & 2047]) - ((0.16666667f * fTemp14) * _state.fRec2[((_state.IOTA0 - iTemp15) & 2047) & 2047]))) + ((0.25f * fTemp16) * _state.fRec2[((_state.IOTA0 - iTemp17) & 2047) & 2047]))) - ((0.16666667f * fTemp18) * _state.fRec2[((_state.IOTA0 - iTemp19) & 2047) & 2047]))) + ((0.041666668f * fTemp20) * _state.fRec2[((_state.IOTA0 - iTemp21) & 2047) & 2047]);
+            fRec4 = fRec8;
+            fRec5 = fRec9;
+            _state.fRec0[0] = fRec3;
+            fRec1 = fRec5;
+            fTemp22 = _state.fSlow0 * fRec1;
+            _io.output0 = (_io.output0 + fTemp22);
+            _io.output1 = (_io.output1 + fTemp22);
+            _state.iRec6[1] = _state.iRec6[0];
+            _state.iVec0[1] = _state.iVec0[0];
+            _state.fRec12[1] = _state.fRec12[0];
+            _state.fVec1[1] = _state.fVec1[0];
+            _state.fRec13[1] = _state.fRec13[0];
+            _state.fRec14[1] = _state.fRec14[0];
+            _state.fRec16[1] = _state.fRec16[0];
+            _state.iRec20[1] = _state.iRec20[0];
+            _state.fRec19[2] = _state.fRec19[1];
+            _state.fRec19[1] = _state.fRec19[0];
+            _state.fRec17[1] = _state.fRec17[0];
+            _state.IOTA0 = (_state.IOTA0 + 1);
+            _state.fVec3[1] = _state.fVec3[0];
+            _state.fRec11[1] = _state.fRec11[0];
+            _state.fRec0[1] = _state.fRec0[0];
+            return;
+        }
+    }
+
+    void faust__voice__control (faust_voice_1_State& _state) noexcept
+    {
+        _state.fSlow0 = _state.fHslider0;
+        _state.fSlow1 = _state.fHslider1;
+        _state.fSlow2 = (1.0f - _state.fSlow1);
+        _state.fSlow3 = (170.0f / _state.fHslider2);
+        _state.fSlow4 = intrinsics::pow (2.0f, 0.083333336f * _state.fHslider3);
+        _state.fSlow5 = intrinsics::min (1.0f, _state.fButton0 + _state.fHslider4);
+        _state.iSlow6 = static_cast<int32_t> (_state.fSlow5 == 0.0f);
+        _state.fSlow7 = (0.01f * _state.fHslider5);
+        _state.fSlow8 = (0.001f * _state.fHslider7);
+        _state.iSlow9 = static_cast<int32_t> (intrinsics::abs (_state.fSlow8) < 1.1920929e-7f);
+        _state.fSlow10 = (static_cast<bool> (_state.iSlow9) ? 0.0f : intrinsics::exp (- (_state.fConst2 / (static_cast<bool> (_state.iSlow9) ? 1.0f : _state.fSlow8))));
+        _state.fSlow11 = ((_state.fHslider6 * _state.fSlow5) * (1.0f - _state.fSlow10));
+        _state.fSlow12 = (_state.fConst2 * _state.fHslider8);
+        _state.fSlow13 = ((0.26f * _state.fHslider9) + -0.44f);
+    }
+
+    float std__intrinsics__abs (float n) noexcept
+    {
+        {
+            return (n < static_cast<float> (0)) ? (- n) : n;
+        }
+    }
+
+    float std__intrinsics__exp (float n) noexcept
+    {
+        {
+            return 0.0f;
+        }
+    }
+
+    int32_t std__intrinsics__max_0 (int32_t v1, int32_t v2) noexcept
+    {
+        {
+            return (v1 > v2) ? v1 : v2;
+        }
+    }
+
+    int32_t std__intrinsics__min_0 (int32_t v1, int32_t v2) noexcept
+    {
+        {
+            return (v1 < v2) ? v1 : v2;
+        }
+    }
+
+    void faust__reverb__main (faust_reverb_1_State& _state, faust_reverb_1_IO& _io) noexcept
+    {
+        float  fTemp0;
+        float  fTemp1;
+        float  fTemp2;
+        float  fTemp3;
+        float  fTemp4;
+        float  fTemp5;
+        float  fRec13;
+        float  fTemp6;
+        float  fRec17;
+        float  fTemp7;
+        float  fRec21;
+        float  fTemp8;
+        float  fRec25;
+        float  fTemp9;
+        float  fTemp10;
+        float  fRec29;
+        float  fTemp11;
+        float  fRec33;
+        float  fTemp12;
+        float  fRec37;
+        float  fTemp13;
+        float  fRec41;
+        float  fTemp14;
+        float  fTemp15;
+        float  fTemp16;
+        float  fTemp17;
+        float  fTemp18;
+        float  fTemp19;
+        float  fTemp20;
+        float  fTemp21;
+        float  fTemp22;
+        float  fTemp23;
+        float  fTemp24;
+        float  fTemp25;
+        float  fTemp26;
+        float  fTemp27;
+        float  fTemp28;
+        float  fTemp29;
+        float  fTemp30;
+        float  fTemp31;
+        float  fTemp32;
+        float  fTemp33;
+        float  fTemp34;
+        float  fTemp35;
+        float  fTemp36;
+        float  fTemp37;
+        float  fTemp38;
+
+        for (;;)
+        {
+            if (_state.fUpdated)
+            {
+                _state.fUpdated = false;
+                faust__reverb__control (_state);
+            }
+            _state.fRec0[0] = (_state.fSlow0 + (_state.fConst2 * _state.fRec0[1]));
+            fTemp0 = _io.input0;
+            _state.fVec0[(_state.IOTA0 & 16383) & 16383] = fTemp0;
+            _state.fRec1[0] = (_state.fSlow1 + (_state.fConst2 * _state.fRec1[1]));
+            fTemp1 = _state.fRec1[0] + 1.0f;
+            fTemp2 = 1.0f - (0.5f * fTemp1);
+            _state.fRec15[0] = (- (_state.fSlow18 * ((_state.fSlow19 * _state.fRec15[1]) - (_state.fRec11[1] + _state.fRec11[2]))));
+            _state.fRec14[0] = ((_state.fSlow14 * (_state.fRec11[1] + (_state.fSlow16 * _state.fRec15[0]))) + (_state.fSlow20 * _state.fRec14[1]));
+            _state.fVec1[(_state.IOTA0 & 32767) & 32767] = ((0.35355338f * _state.fRec14[0]) + 1e-20f);
+            fTemp3 = (0.6f * _state.fRec12[1]) + _state.fVec1[((_state.IOTA0 - _state.iConst8) & 32767) & 32767];
+            fTemp4 = _io.input1;
+            _state.fVec2[(_state.IOTA0 & 16383) & 16383] = fTemp4;
+            fTemp5 = 0.3f * _state.fVec2[((_state.IOTA0 - _state.iSlow21) & 16383) & 16383];
+            _state.fVec3[(_state.IOTA0 & 2047) & 2047] = (fTemp3 - fTemp5);
+            _state.fRec12[0] = _state.fVec3[((_state.IOTA0 - _state.iConst10) & 2047) & 2047];
+            fRec13 = 0.6f * (fTemp5 - fTemp3);
+            _state.fRec19[0] = (- (_state.fSlow18 * ((_state.fSlow19 * _state.fRec19[1]) - (_state.fRec7[1] + _state.fRec7[2]))));
+            _state.fRec18[0] = ((_state.fSlow28 * (_state.fRec7[1] + (_state.fSlow29 * _state.fRec19[0]))) + (_state.fSlow30 * _state.fRec18[1]));
+            _state.fVec4[(_state.IOTA0 & 32767) & 32767] = ((0.35355338f * _state.fRec18[0]) + 1e-20f);
+            fTemp6 = (0.6f * _state.fRec16[1]) + _state.fVec4[((_state.IOTA0 - _state.iConst14) & 32767) & 32767];
+            _state.fVec5[(_state.IOTA0 & 4095) & 4095] = (fTemp6 - fTemp5);
+            _state.fRec16[0] = _state.fVec5[((_state.IOTA0 - _state.iConst15) & 4095) & 4095];
+            fRec17 = 0.6f * (fTemp5 - fTemp6);
+            _state.fRec23[0] = (- (_state.fSlow18 * ((_state.fSlow19 * _state.fRec23[1]) - (_state.fRec9[1] + _state.fRec9[2]))));
+            _state.fRec22[0] = ((_state.fSlow37 * (_state.fRec9[1] + (_state.fSlow38 * _state.fRec23[0]))) + (_state.fSlow39 * _state.fRec22[1]));
+            _state.fVec6[(_state.IOTA0 & 16383) & 16383] = ((0.35355338f * _state.fRec22[0]) + 1e-20f);
+            fTemp7 = (_state.fVec6[((_state.IOTA0 - _state.iConst19) & 16383) & 16383] + fTemp5) + (0.6f * _state.fRec20[1]);
+            _state.fVec7[(_state.IOTA0 & 4095) & 4095] = fTemp7;
+            _state.fRec20[0] = _state.fVec7[((_state.IOTA0 - _state.iConst20) & 4095) & 4095];
+            fRec21 = - (0.6f * fTemp7);
+            _state.fRec27[0] = (- (_state.fSlow18 * ((_state.fSlow19 * _state.fRec27[1]) - (_state.fRec5[1] + _state.fRec5[2]))));
+            _state.fRec26[0] = ((_state.fSlow46 * (_state.fRec5[1] + (_state.fSlow47 * _state.fRec27[0]))) + (_state.fSlow48 * _state.fRec26[1]));
+            _state.fVec8[(_state.IOTA0 & 32767) & 32767] = ((0.35355338f * _state.fRec26[0]) + 1e-20f);
+            fTemp8 = (fTemp5 + (0.6f * _state.fRec24[1])) + _state.fVec8[((_state.IOTA0 - _state.iConst24) & 32767) & 32767];
+            _state.fVec9[(_state.IOTA0 & 4095) & 4095] = fTemp8;
+            _state.fRec24[0] = _state.fVec9[((_state.IOTA0 - _state.iConst25) & 4095) & 4095];
+            fRec25 = - (0.6f * fTemp8);
+            _state.fRec31[0] = (- (_state.fSlow18 * ((_state.fSlow19 * _state.fRec31[1]) - (_state.fRec10[1] + _state.fRec10[2]))));
+            _state.fRec30[0] = ((_state.fSlow55 * (_state.fRec10[1] + (_state.fSlow56 * _state.fRec31[0]))) + (_state.fSlow57 * _state.fRec30[1]));
+            _state.fVec10[(_state.IOTA0 & 16383) & 16383] = ((0.35355338f * _state.fRec30[0]) + 1e-20f);
+            fTemp9 = 0.3f * _state.fVec0[((_state.IOTA0 - _state.iSlow21) & 16383) & 16383];
+            fTemp10 = _state.fVec10[((_state.IOTA0 - _state.iConst29) & 16383) & 16383] - (fTemp9 + (0.6f * _state.fRec28[1]));
+            _state.fVec11[(_state.IOTA0 & 2047) & 2047] = fTemp10;
+            _state.fRec28[0] = _state.fVec11[((_state.IOTA0 - _state.iConst30) & 2047) & 2047];
+            fRec29 = 0.6f * fTemp10;
+            _state.fRec35[0] = (- (_state.fSlow18 * ((_state.fSlow19 * _state.fRec35[1]) - (_state.fRec6[1] + _state.fRec6[2]))));
+            _state.fRec34[0] = ((_state.fSlow64 * (_state.fRec6[1] + (_state.fSlow65 * _state.fRec35[0]))) + (_state.fSlow66 * _state.fRec34[1]));
+            _state.fVec12[(_state.IOTA0 & 16383) & 16383] = ((0.35355338f * _state.fRec34[0]) + 1e-20f);
+            fTemp11 = _state.fVec12[((_state.IOTA0 - _state.iConst34) & 16383) & 16383] - (fTemp9 + (0.6f * _state.fRec32[1]));
+            _state.fVec13[(_state.IOTA0 & 4095) & 4095] = fTemp11;
+            _state.fRec32[0] = _state.fVec13[((_state.IOTA0 - _state.iConst35) & 4095) & 4095];
+            fRec33 = 0.6f * fTemp11;
+            _state.fRec39[0] = (- (_state.fSlow18 * ((_state.fSlow19 * _state.fRec39[1]) - (_state.fRec8[1] + _state.fRec8[2]))));
+            _state.fRec38[0] = ((_state.fSlow73 * (_state.fRec8[1] + (_state.fSlow74 * _state.fRec39[0]))) + (_state.fSlow75 * _state.fRec38[1]));
+            _state.fVec14[(_state.IOTA0 & 16383) & 16383] = ((0.35355338f * _state.fRec38[0]) + 1e-20f);
+            fTemp12 = (fTemp9 + _state.fVec14[((_state.IOTA0 - _state.iConst39) & 16383) & 16383]) - (0.6f * _state.fRec36[1]);
+            _state.fVec15[(_state.IOTA0 & 4095) & 4095] = fTemp12;
+            _state.fRec36[0] = _state.fVec15[((_state.IOTA0 - _state.iConst40) & 4095) & 4095];
+            fRec37 = 0.6f * fTemp12;
+            _state.fRec43[0] = (- (_state.fSlow18 * ((_state.fSlow19 * _state.fRec43[1]) - (_state.fRec4[1] + _state.fRec4[2]))));
+            _state.fRec42[0] = ((_state.fSlow82 * (_state.fRec4[1] + (_state.fSlow83 * _state.fRec43[0]))) + (_state.fSlow84 * _state.fRec42[1]));
+            _state.fVec16[(_state.IOTA0 & 16383) & 16383] = ((0.35355338f * _state.fRec42[0]) + 1e-20f);
+            fTemp13 = (_state.fVec16[((_state.IOTA0 - _state.iConst44) & 16383) & 16383] + fTemp9) - (0.6f * _state.fRec40[1]);
+            _state.fVec17[(_state.IOTA0 & 2047) & 2047] = fTemp13;
+            _state.fRec40[0] = _state.fVec17[((_state.IOTA0 - _state.iConst45) & 2047) & 2047];
+            fRec41 = 0.6f * fTemp13;
+            fTemp14 = fRec41 + fRec37;
+            fTemp15 = (fRec29 + fRec33) + fTemp14;
+            _state.fRec4[0] = ((((((((((((_state.fRec12[1] + _state.fRec16[1]) + _state.fRec20[1]) + _state.fRec24[1]) + _state.fRec28[1]) + _state.fRec32[1]) + _state.fRec36[1]) + _state.fRec40[1]) + fRec13) + fRec17) + fRec21) + fRec25) + fTemp15);
+            _state.fRec5[0] = (((((_state.fRec28[1] + _state.fRec32[1]) + _state.fRec36[1]) + _state.fRec40[1]) + fTemp15) - (((((((_state.fRec12[1] + _state.fRec16[1]) + _state.fRec20[1]) + _state.fRec24[1]) + fRec13) + fRec17) + fRec25) + fRec21));
+            fTemp16 = fRec33 + fRec29;
+            _state.fRec6[0] = (((((((_state.fRec20[1] + _state.fRec24[1]) + _state.fRec36[1]) + _state.fRec40[1]) + fRec21) + fRec25) + fTemp14) - ((((((_state.fRec12[1] + _state.fRec16[1]) + _state.fRec28[1]) + _state.fRec32[1]) + fRec13) + fRec17) + fTemp16));
+            _state.fRec7[0] = (((((((_state.fRec12[1] + _state.fRec16[1]) + _state.fRec36[1]) + _state.fRec40[1]) + fRec13) + fRec17) + fTemp14) - ((((((_state.fRec20[1] + _state.fRec24[1]) + _state.fRec28[1]) + _state.fRec32[1]) + fRec21) + fRec25) + fTemp16));
+            fTemp17 = fRec41 + fRec33;
+            fTemp18 = fRec37 + fRec29;
+            _state.fRec8[0] = (((((((_state.fRec16[1] + _state.fRec24[1]) + _state.fRec32[1]) + _state.fRec40[1]) + fRec17) + fRec25) + fTemp17) - ((((((_state.fRec12[1] + _state.fRec20[1]) + _state.fRec28[1]) + _state.fRec36[1]) + fRec13) + fRec21) + fTemp18));
+            _state.fRec9[0] = (((((((_state.fRec12[1] + _state.fRec20[1]) + _state.fRec32[1]) + _state.fRec40[1]) + fRec13) + fRec21) + fTemp17) - ((((((_state.fRec16[1] + _state.fRec24[1]) + _state.fRec28[1]) + _state.fRec36[1]) + fRec17) + fRec25) + fTemp18));
+            fTemp19 = fRec41 + fRec29;
+            fTemp20 = fRec37 + fRec33;
+            _state.fRec10[0] = (((((((_state.fRec12[1] + _state.fRec24[1]) + _state.fRec28[1]) + _state.fRec40[1]) + fRec13) + fRec25) + fTemp19) - ((((((_state.fRec16[1] + _state.fRec20[1]) + _state.fRec32[1]) + _state.fRec36[1]) + fRec17) + fRec21) + fTemp20));
+            _state.fRec11[0] = (((((((_state.fRec16[1] + _state.fRec20[1]) + _state.fRec28[1]) + _state.fRec40[1]) + fRec17) + fRec21) + fTemp19) - ((((((_state.fRec12[1] + _state.fRec24[1]) + _state.fRec32[1]) + _state.fRec36[1]) + fRec13) + fRec25) + fTemp20));
+            fTemp21 = 0.37f * (_state.fRec5[0] + _state.fRec6[0]);
+            fTemp22 = _state.fSlow85 * _state.fRec3[1];
+            fTemp23 = fTemp21 + fTemp22;
+            _state.fRec3[0] = (fTemp23 - (_state.fSlow5 * _state.fRec3[2]));
+            fTemp24 = _state.fSlow5 * _state.fRec3[0];
+            fTemp25 = (fTemp24 + fTemp21) + _state.fRec3[2];
+            fTemp26 = _state.fSlow3 * ((_state.fRec3[2] + fTemp24) - fTemp23);
+            fTemp27 = _state.fSlow90 * _state.fRec2[1];
+            _state.fRec2[0] = (((0.5f * ((fTemp25 - fTemp22) + fTemp26)) + fTemp27) - (_state.fSlow89 * _state.fRec2[2]));
+            fTemp28 = _state.fRec2[2] + (_state.fSlow89 * _state.fRec2[0]);
+            fTemp29 = 0.5f * ((fTemp25 + fTemp26) - fTemp22);
+            _io.output0 = (_io.output0 + ((0.25f * _state.fRec0[0]) * ((fTemp0 * fTemp1) + (fTemp2 * (((fTemp28 + fTemp29) + (_state.fSlow87 * (fTemp28 - (fTemp27 + fTemp29)))) - fTemp27)))));
+            fTemp30 = 0.37f * (_state.fRec5[0] - _state.fRec6[0]);
+            fTemp31 = _state.fSlow85 * _state.fRec45[1];
+            fTemp32 = fTemp30 + fTemp31;
+            _state.fRec45[0] = (fTemp32 - (_state.fSlow5 * _state.fRec45[2]));
+            fTemp33 = _state.fSlow5 * _state.fRec45[0];
+            fTemp34 = (fTemp33 + fTemp30) + _state.fRec45[2];
+            fTemp35 = _state.fSlow3 * ((_state.fRec45[2] + fTemp33) - fTemp32);
+            fTemp36 = _state.fSlow90 * _state.fRec44[1];
+            _state.fRec44[0] = (((0.5f * ((fTemp34 - fTemp31) + fTemp35)) + fTemp36) - (_state.fSlow89 * _state.fRec44[2]));
+            fTemp37 = _state.fRec44[2] + (_state.fSlow89 * _state.fRec44[0]);
+            fTemp38 = 0.5f * ((fTemp34 + fTemp35) - fTemp31);
+            _io.output1 = (_io.output1 + ((0.25f * _state.fRec0[0]) * ((fTemp4 * fTemp1) + (fTemp2 * (((fTemp37 + fTemp38) + (_state.fSlow87 * (fTemp37 - (fTemp36 + fTemp38)))) - fTemp36)))));
+            _state.fRec0[1] = _state.fRec0[0];
+            _state.IOTA0 = (_state.IOTA0 + 1);
+            _state.fRec1[1] = _state.fRec1[0];
+            _state.fRec15[1] = _state.fRec15[0];
+            _state.fRec14[1] = _state.fRec14[0];
+            _state.fRec12[1] = _state.fRec12[0];
+            _state.fRec19[1] = _state.fRec19[0];
+            _state.fRec18[1] = _state.fRec18[0];
+            _state.fRec16[1] = _state.fRec16[0];
+            _state.fRec23[1] = _state.fRec23[0];
+            _state.fRec22[1] = _state.fRec22[0];
+            _state.fRec20[1] = _state.fRec20[0];
+            _state.fRec27[1] = _state.fRec27[0];
+            _state.fRec26[1] = _state.fRec26[0];
+            _state.fRec24[1] = _state.fRec24[0];
+            _state.fRec31[1] = _state.fRec31[0];
+            _state.fRec30[1] = _state.fRec30[0];
+            _state.fRec28[1] = _state.fRec28[0];
+            _state.fRec35[1] = _state.fRec35[0];
+            _state.fRec34[1] = _state.fRec34[0];
+            _state.fRec32[1] = _state.fRec32[0];
+            _state.fRec39[1] = _state.fRec39[0];
+            _state.fRec38[1] = _state.fRec38[0];
+            _state.fRec36[1] = _state.fRec36[0];
+            _state.fRec43[1] = _state.fRec43[0];
+            _state.fRec42[1] = _state.fRec42[0];
+            _state.fRec40[1] = _state.fRec40[0];
+            _state.fRec4[2] = _state.fRec4[1];
+            _state.fRec4[1] = _state.fRec4[0];
+            _state.fRec5[2] = _state.fRec5[1];
+            _state.fRec5[1] = _state.fRec5[0];
+            _state.fRec6[2] = _state.fRec6[1];
+            _state.fRec6[1] = _state.fRec6[0];
+            _state.fRec7[2] = _state.fRec7[1];
+            _state.fRec7[1] = _state.fRec7[0];
+            _state.fRec8[2] = _state.fRec8[1];
+            _state.fRec8[1] = _state.fRec8[0];
+            _state.fRec9[2] = _state.fRec9[1];
+            _state.fRec9[1] = _state.fRec9[0];
+            _state.fRec10[2] = _state.fRec10[1];
+            _state.fRec10[1] = _state.fRec10[0];
+            _state.fRec11[2] = _state.fRec11[1];
+            _state.fRec11[1] = _state.fRec11[0];
+            _state.fRec3[2] = _state.fRec3[1];
+            _state.fRec3[1] = _state.fRec3[0];
+            _state.fRec2[2] = _state.fRec2[1];
+            _state.fRec2[1] = _state.fRec2[0];
+            _state.fRec45[2] = _state.fRec45[1];
+            _state.fRec45[1] = _state.fRec45[0];
+            _state.fRec44[2] = _state.fRec44[1];
+            _state.fRec44[1] = _state.fRec44[0];
+            return;
+        }
+    }
+
+    void faust__reverb__control (faust_reverb_1_State& _state) noexcept
+    {
+        _state.fSlow0 = (_state.fConst1 * intrinsics::pow (10.0f, 0.05f * _state.fVslider0));
+        _state.fSlow1 = (_state.fConst1 * _state.fVslider1);
+        _state.fSlow2 = _state.fVslider2;
+        _state.fSlow3 = intrinsics::pow (10.0f, 0.05f * _state.fVslider3);
+        _state.fSlow4 = (_state.fConst3 * (_state.fSlow2 / intrinsics::sqrt (intrinsics::max (0.0f, _state.fSlow3))));
+        _state.fSlow5 = ((1.0f - _state.fSlow4) / (_state.fSlow4 + 1.0f));
+        _state.fSlow6 = _state.fVslider4;
+        _state.fSlow7 = intrinsics::exp (- (_state.fConst5 / _state.fSlow6));
+        _state.fSlow8 = intrinsics::cos (_state.fConst3 * _state.fVslider5);
+        _state.fSlow9 = intrinsics::pow (_state.fSlow7, 2.0f);
+        _state.fSlow10 = (1.0f - (_state.fSlow8 * _state.fSlow9));
+        _state.fSlow11 = (1.0f - _state.fSlow9);
+        _state.fSlow12 = intrinsics::sqrt (intrinsics::max (0.0f, (intrinsics::pow (_state.fSlow10, 2.0f) / intrinsics::pow (_state.fSlow11, 2.0f)) + -1.0f));
+        _state.fSlow13 = (_state.fSlow10 / _state.fSlow11);
+        _state.fSlow14 = (_state.fSlow7 * (_state.fSlow12 + (1.0f - _state.fSlow13)));
+        _state.fSlow15 = _state.fVslider6;
+        _state.fSlow16 = ((intrinsics::exp (- (_state.fConst5 / _state.fSlow15)) / _state.fSlow7) + -1.0f);
+        _state.fSlow17 = (1.0f / intrinsics::tan (_state.fConst6 * _state.fVslider7));
+        _state.fSlow18 = (1.0f / (_state.fSlow17 + 1.0f));
+        _state.fSlow19 = (1.0f - _state.fSlow17);
+        _state.fSlow20 = (_state.fSlow13 - _state.fSlow12);
+        _state.iSlow21 = static_cast<int32_t> (intrinsics::min (8192.0f, intrinsics::max (0.0f, _state.fConst9 * _state.fVslider8)));
+        _state.fSlow22 = intrinsics::exp (- (_state.fConst12 / _state.fSlow6));
+        _state.fSlow23 = intrinsics::pow (_state.fSlow22, 2.0f);
+        _state.fSlow24 = (1.0f - (_state.fSlow8 * _state.fSlow23));
+        _state.fSlow25 = (1.0f - _state.fSlow23);
+        _state.fSlow26 = intrinsics::sqrt (intrinsics::max (0.0f, (intrinsics::pow (_state.fSlow24, 2.0f) / intrinsics::pow (_state.fSlow25, 2.0f)) + -1.0f));
+        _state.fSlow27 = (_state.fSlow24 / _state.fSlow25);
+        _state.fSlow28 = (_state.fSlow22 * (_state.fSlow26 + (1.0f - _state.fSlow27)));
+        _state.fSlow29 = ((intrinsics::exp (- (_state.fConst12 / _state.fSlow15)) / _state.fSlow22) + -1.0f);
+        _state.fSlow30 = (_state.fSlow27 - _state.fSlow26);
+        _state.fSlow31 = intrinsics::exp (- (_state.fConst17 / _state.fSlow6));
+        _state.fSlow32 = intrinsics::pow (_state.fSlow31, 2.0f);
+        _state.fSlow33 = (1.0f - (_state.fSlow8 * _state.fSlow32));
+        _state.fSlow34 = (1.0f - _state.fSlow32);
+        _state.fSlow35 = intrinsics::sqrt (intrinsics::max (0.0f, (intrinsics::pow (_state.fSlow33, 2.0f) / intrinsics::pow (_state.fSlow34, 2.0f)) + -1.0f));
+        _state.fSlow36 = (_state.fSlow33 / _state.fSlow34);
+        _state.fSlow37 = (_state.fSlow31 * (_state.fSlow35 + (1.0f - _state.fSlow36)));
+        _state.fSlow38 = ((intrinsics::exp (- (_state.fConst17 / _state.fSlow15)) / _state.fSlow31) + -1.0f);
+        _state.fSlow39 = (_state.fSlow36 - _state.fSlow35);
+        _state.fSlow40 = intrinsics::exp (- (_state.fConst22 / _state.fSlow6));
+        _state.fSlow41 = intrinsics::pow (_state.fSlow40, 2.0f);
+        _state.fSlow42 = (1.0f - (_state.fSlow8 * _state.fSlow41));
+        _state.fSlow43 = (1.0f - _state.fSlow41);
+        _state.fSlow44 = intrinsics::sqrt (intrinsics::max (0.0f, (intrinsics::pow (_state.fSlow42, 2.0f) / intrinsics::pow (_state.fSlow43, 2.0f)) + -1.0f));
+        _state.fSlow45 = (_state.fSlow42 / _state.fSlow43);
+        _state.fSlow46 = (_state.fSlow40 * (_state.fSlow44 + (1.0f - _state.fSlow45)));
+        _state.fSlow47 = ((intrinsics::exp (- (_state.fConst22 / _state.fSlow15)) / _state.fSlow40) + -1.0f);
+        _state.fSlow48 = (_state.fSlow45 - _state.fSlow44);
+        _state.fSlow49 = intrinsics::exp (- (_state.fConst27 / _state.fSlow6));
+        _state.fSlow50 = intrinsics::pow (_state.fSlow49, 2.0f);
+        _state.fSlow51 = (1.0f - (_state.fSlow8 * _state.fSlow50));
+        _state.fSlow52 = (1.0f - _state.fSlow50);
+        _state.fSlow53 = intrinsics::sqrt (intrinsics::max (0.0f, (intrinsics::pow (_state.fSlow51, 2.0f) / intrinsics::pow (_state.fSlow52, 2.0f)) + -1.0f));
+        _state.fSlow54 = (_state.fSlow51 / _state.fSlow52);
+        _state.fSlow55 = (_state.fSlow49 * (_state.fSlow53 + (1.0f - _state.fSlow54)));
+        _state.fSlow56 = ((intrinsics::exp (- (_state.fConst27 / _state.fSlow15)) / _state.fSlow49) + -1.0f);
+        _state.fSlow57 = (_state.fSlow54 - _state.fSlow53);
+        _state.fSlow58 = intrinsics::exp (- (_state.fConst32 / _state.fSlow6));
+        _state.fSlow59 = intrinsics::pow (_state.fSlow58, 2.0f);
+        _state.fSlow60 = (1.0f - (_state.fSlow8 * _state.fSlow59));
+        _state.fSlow61 = (1.0f - _state.fSlow59);
+        _state.fSlow62 = intrinsics::sqrt (intrinsics::max (0.0f, (intrinsics::pow (_state.fSlow60, 2.0f) / intrinsics::pow (_state.fSlow61, 2.0f)) + -1.0f));
+        _state.fSlow63 = (_state.fSlow60 / _state.fSlow61);
+        _state.fSlow64 = (_state.fSlow58 * (_state.fSlow62 + (1.0f - _state.fSlow63)));
+        _state.fSlow65 = ((intrinsics::exp (- (_state.fConst32 / _state.fSlow15)) / _state.fSlow58) + -1.0f);
+        _state.fSlow66 = (_state.fSlow63 - _state.fSlow62);
+        _state.fSlow67 = intrinsics::exp (- (_state.fConst37 / _state.fSlow6));
+        _state.fSlow68 = intrinsics::pow (_state.fSlow67, 2.0f);
+        _state.fSlow69 = (1.0f - (_state.fSlow8 * _state.fSlow68));
+        _state.fSlow70 = (1.0f - _state.fSlow68);
+        _state.fSlow71 = intrinsics::sqrt (intrinsics::max (0.0f, (intrinsics::pow (_state.fSlow69, 2.0f) / intrinsics::pow (_state.fSlow70, 2.0f)) + -1.0f));
+        _state.fSlow72 = (_state.fSlow69 / _state.fSlow70);
+        _state.fSlow73 = (_state.fSlow67 * (_state.fSlow71 + (1.0f - _state.fSlow72)));
+        _state.fSlow74 = ((intrinsics::exp (- (_state.fConst37 / _state.fSlow15)) / _state.fSlow67) + -1.0f);
+        _state.fSlow75 = (_state.fSlow72 - _state.fSlow71);
+        _state.fSlow76 = intrinsics::exp (- (_state.fConst42 / _state.fSlow6));
+        _state.fSlow77 = intrinsics::pow (_state.fSlow76, 2.0f);
+        _state.fSlow78 = (1.0f - (_state.fSlow77 * _state.fSlow8));
+        _state.fSlow79 = (1.0f - _state.fSlow77);
+        _state.fSlow80 = intrinsics::sqrt (intrinsics::max (0.0f, (intrinsics::pow (_state.fSlow78, 2.0f) / intrinsics::pow (_state.fSlow79, 2.0f)) + -1.0f));
+        _state.fSlow81 = (_state.fSlow78 / _state.fSlow79);
+        _state.fSlow82 = (_state.fSlow76 * (_state.fSlow80 + (1.0f - _state.fSlow81)));
+        _state.fSlow83 = ((intrinsics::exp (- (_state.fConst42 / _state.fSlow15)) / _state.fSlow76) + -1.0f);
+        _state.fSlow84 = (_state.fSlow81 - _state.fSlow80);
+        _state.fSlow85 = (intrinsics::cos (_state.fConst3 * _state.fSlow2) * (_state.fSlow5 + 1.0f));
+        _state.fSlow86 = _state.fVslider9;
+        _state.fSlow87 = intrinsics::pow (10.0f, 0.05f * _state.fVslider10);
+        _state.fSlow88 = (_state.fConst3 * (_state.fSlow86 / intrinsics::sqrt (intrinsics::max (0.0f, _state.fSlow87))));
+        _state.fSlow89 = ((1.0f - _state.fSlow88) / (_state.fSlow88 + 1.0f));
+        _state.fSlow90 = (intrinsics::cos (_state.fConst3 * _state.fSlow86) * (_state.fSlow89 + 1.0f));
+    }
+
+    float std__intrinsics__sqrt (float n) noexcept
+    {
+        {
+            return 0.0f;
+        }
+    }
+
+    void faust__echo__main (faust_echo_1_State& _state, faust_reverb_1_IO& _io) noexcept
+    {
+        for (;;)
+        {
+            if (_state.fUpdated)
+            {
+                _state.fUpdated = false;
+                faust__echo__control (_state);
+            }
+            _state.fRec0[(_state.IOTA0 & 0x1fffff) & 0x1fffff] = (_io.input0 + (0.7f * _state.fRec0[((_state.IOTA0 - _state.iSlow0) & 0x1fffff) & 0x1fffff]));
+            _io.output0 = (_io.output0 + _state.fRec0[(_state.IOTA0 & 0x1fffff) & 0x1fffff]);
+            _state.fRec1[(_state.IOTA0 & 0x1fffff) & 0x1fffff] = (_io.input1 + (0.7f * _state.fRec1[((_state.IOTA0 - _state.iSlow0) & 0x1fffff) & 0x1fffff]));
+            _io.output1 = (_io.output1 + _state.fRec1[(_state.IOTA0 & 0x1fffff) & 0x1fffff]);
+            _state.IOTA0 = (_state.IOTA0 + 1);
+            return;
+        }
+    }
+
+    void faust__echo__control (faust_echo_1_State& _state) noexcept
+    {
+        _state.iSlow0 = (static_cast<int32_t> (_state.fConst0 * _state.fVslider0) + 1);
+    }
+
+    //==============================================================================
+    const char* getStringForHandle (uint32_t handle, size_t& stringLength)
+    {
+        (void) handle; (void) stringLength;
+        return "";
+    }
+
+    //==============================================================================
+    int32_t _sessionID {};
+    double _frequency {};
+    const Array<_HelloWorld_1_Note, 13> melody { Array<_HelloWorld_1_Note, 13> { _HelloWorld_1_Note { 79, 1 }, _HelloWorld_1_Note { 77, 1 }, _HelloWorld_1_Note { 69, 2 }, _HelloWorld_1_Note { 71, 2 }, _HelloWorld_1_Note { 76, 1 }, _HelloWorld_1_Note { 74, 1 }, _HelloWorld_1_Note { 65, 2 }, _HelloWorld_1_Note { 67, 2 }, _HelloWorld_1_Note { 74, 1 }, _HelloWorld_1_Note { 72, 1 }, _HelloWorld_1_Note { 64, 2 }, _HelloWorld_1_Note { 67, 2 }, _HelloWorld_1_Note { 72, 4 } } };
+    static constexpr float volume { 0.15f };
+
+    //==============================================================================
+    struct intrinsics
+    {
+        template <typename T> static T modulo (T a, T b)
+        {
+            if constexpr (std::is_floating_point<T>::value)
+                return std::fmod (a, b);
+            else
+                return a % b;
+        }
+
+        template <typename T> static T addModulo2Pi (T a, T b)
+        {
+            constexpr auto twoPi = static_cast<T> (3.141592653589793238 * 2);
+            auto n = a + b;
+            return n >= twoPi ? std::remainder (n, twoPi) : n;
+        }
+
+        template <typename T> static T abs           (T a)              { return std::abs (a); }
+        template <typename T> static T min           (T a, T b)         { return std::min (a, b); }
+        template <typename T> static T max           (T a, T b)         { return std::max (a, b); }
+        template <typename T> static T clamp         (T a, T b, T c)    { return a < b ? b : (a > c ? c : a); }
+        template <typename T> static T wrap          (T a, T b)         { if (b == 0) return 0; auto n = modulo (a, b); if (n < 0) n += b; return n; }
+        template <typename T> static T fmod          (T a, T b)         { return b != 0 ? std::fmod (a, b) : 0; }
+        template <typename T> static T remainder     (T a, T b)         { return b != 0 ? std::remainder (a, b) : 0; }
+        template <typename T> static T floor         (T a)              { return std::floor (a); }
+        template <typename T> static T ceil          (T a)              { return std::ceil (a); }
+        template <typename T> static T rint          (T a)              { return std::rint (a); }
+        template <typename T> static T sqrt          (T a)              { return std::sqrt (a); }
+        template <typename T> static T pow           (T a, T b)         { return std::pow (a, b); }
+        template <typename T> static T exp           (T a)              { return std::exp (a); }
+        template <typename T> static T log           (T a)              { return std::log (a); }
+        template <typename T> static T log10         (T a)              { return std::log10 (a); }
+        template <typename T> static T sin           (T a)              { return std::sin (a); }
+        template <typename T> static T cos           (T a)              { return std::cos (a); }
+        template <typename T> static T tan           (T a)              { return std::tan (a); }
+        template <typename T> static T sinh          (T a)              { return std::sinh (a); }
+        template <typename T> static T cosh          (T a)              { return std::cosh (a); }
+        template <typename T> static T tanh          (T a)              { return std::tanh (a); }
+        template <typename T> static T asinh         (T a)              { return std::asinh (a); }
+        template <typename T> static T acosh         (T a)              { return std::acosh (a); }
+        template <typename T> static T atanh         (T a)              { return std::atanh (a); }
+        template <typename T> static T asin          (T a)              { return std::asin (a); }
+        template <typename T> static T acos          (T a)              { return std::acos (a); }
+        template <typename T> static T atan          (T a)              { return std::atan (a); }
+        template <typename T> static T atan2         (T a, T b)         { return std::atan2 (a, b); }
+        template <typename T> static T isnan         (T a)              { return std::isnan (a) ? 1 : 0; }
+        template <typename T> static T isinf         (T a)              { return std::isinf (a) ? 1 : 0; }
+
+        static int32_t reinterpretFloatToInt (float   a)                { int32_t i; memcpy (std::addressof(i), std::addressof(a), sizeof(i)); return i; }
+        static int64_t reinterpretFloatToInt (double  a)                { int64_t i; memcpy (std::addressof(i), std::addressof(a), sizeof(i)); return i; }
+        static float   reinterpretIntToFloat (int32_t a)                { float   f; memcpy (std::addressof(f), std::addressof(a), sizeof(f)); return f; }
+        static double  reinterpretIntToFloat (int64_t a)                { double  f; memcpy (std::addressof(f), std::addressof(a), sizeof(f)); return f; }
+
+        static int32_t rightShiftUnsigned (int32_t a, int32_t b)        { return static_cast<int32_t> (static_cast<uint32_t> (a) >> b); }
+        static int64_t rightShiftUnsigned (int64_t a, int64_t b)        { return static_cast<int64_t> (static_cast<uint64_t> (a) >> b); }
+
+        struct VectorOps
+        {
+            template <typename Vec> static Vec abs     (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::abs (x); }); }
+            template <typename Vec> static Vec min     (Vec a, Vec b)     { return a.performBinaryOp (b, [] (auto x, auto y) { return intrinsics::min (x, y); }); }
+            template <typename Vec> static Vec max     (Vec a, Vec b)     { return a.performBinaryOp (b, [] (auto x, auto y) { return intrinsics::max (x, y); }); }
+            template <typename Vec> static Vec sqrt    (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::sqrt (x); }); }
+            template <typename Vec> static Vec log     (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::log (x); }); }
+            template <typename Vec> static Vec log10   (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::log10 (x); }); }
+            template <typename Vec> static Vec sin     (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::sin (x); }); }
+            template <typename Vec> static Vec cos     (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::cos (x); }); }
+            template <typename Vec> static Vec tan     (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::tan (x); }); }
+            template <typename Vec> static Vec sinh    (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::sinh (x); }); }
+            template <typename Vec> static Vec cosh    (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::cosh (x); }); }
+            template <typename Vec> static Vec tanh    (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::tanh (x); }); }
+            template <typename Vec> static Vec asinh   (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::asinh (x); }); }
+            template <typename Vec> static Vec acosh   (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::acosh (x); }); }
+            template <typename Vec> static Vec atanh   (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::atanh (x); }); }
+            template <typename Vec> static Vec asin    (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::asin (x); }); }
+            template <typename Vec> static Vec acos    (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::acos (x); }); }
+            template <typename Vec> static Vec atan    (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::atan (x); }); }
+            template <typename Vec> static Vec atan2   (Vec a, Vec b)     { return a.performBinaryOp (b, [] (auto x, auto y) { return intrinsics::atan2 (x, y); }); }
+            template <typename Vec> static Vec pow     (Vec a, Vec b)     { return a.performBinaryOp (b, [] (auto x, auto y) { return intrinsics::pow (x, y); }); }
+            template <typename Vec> static Vec exp     (Vec a)            { return a.performUnaryOp ([] (auto x) { return intrinsics::exp (x); }); }
+        };
+    };
+
+    static constexpr float  _inf32  =  std::numeric_limits<float>::infinity();
+    static constexpr double _inf64  =  std::numeric_limits<double>::infinity();
+    static constexpr float  _ninf32 = -std::numeric_limits<float>::infinity();
+    static constexpr double _ninf64 = -std::numeric_limits<double>::infinity();
+    static constexpr float  _nan32  =  std::numeric_limits<float>::quiet_NaN();
+    static constexpr double _nan64  =  std::numeric_limits<double>::quiet_NaN();
+
+    //==============================================================================
+    #if __clang__
+     #pragma clang diagnostic pop
+    #elif __GNUC__
+     #pragma GCC diagnostic pop
+    #else
+     #pragma warning (pop)
+    #endif
+};
+