/**
 * Copyright (c) 2021 Enzien Audio, Ltd.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions, and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the phrase "powered by heavy",
 *    the heavy logo, and a hyperlink to https://enzienaudio.com, all in a visible
 *    form.
 * 
 *   2.1 If the Application is distributed in a store system (for example,
 *       the Apple "App Store" or "Google Play"), the phrase "powered by heavy"
 *       shall be included in the app description or the copyright text as well as
 *       the in the app itself. The heavy logo will shall be visible in the app
 *       itself as well.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 */

#include "Heavy_arp_delay_env.hpp"

#define Context(_c) reinterpret_cast<Heavy_arp_delay_env *>(_c)



/*
 * C Functions
 */

extern "C" {
  HV_EXPORT HeavyContextInterface *hv_arp_delay_env_new(double sampleRate) {
    return new Heavy_arp_delay_env(sampleRate);
  }

  HV_EXPORT HeavyContextInterface *hv_arp_delay_env_new_with_options(double sampleRate,
      int poolKb, int inQueueKb, int outQueueKb) {
    return new Heavy_arp_delay_env(sampleRate, poolKb, inQueueKb, outQueueKb);
  }
} // extern "C"







/*
 * Class Functions
 */

Heavy_arp_delay_env::Heavy_arp_delay_env(double sampleRate, int poolKb, int inQueueKb, int outQueueKb)
    : HeavyContext(sampleRate, poolKb, inQueueKb, outQueueKb) {
  numBytes += sLine_init(&sLine_5Jrovr0w);
  numBytes += sTabhead_init(&sTabhead_5flIzcsR, &hTable_RQkgAERq);
  numBytes += sTabread_init(&sTabread_3ztnQBI7, &hTable_RQkgAERq, false);
  numBytes += sTabread_init(&sTabread_Va5jECJY, &hTable_RQkgAERq, false);
  numBytes += sPhasor_k_init(&sPhasor_deMq4ELY, 220.0f, sampleRate);
  numBytes += sLine_init(&sLine_tLkWSR92);
  numBytes += sTabwrite_init(&sTabwrite_lra5KFKD, &hTable_RQkgAERq);
  numBytes += cVar_init_f(&cVar_QpNfcxTV, 0.0f);
  numBytes += cDelay_init(this, &cDelay_TiC320ze, 0.0f);
  numBytes += cVar_init_f(&cVar_BG8d1bMD, 300.0f);
  numBytes += cBinop_init(&cBinop_aL2oj1zg, 0.0f); // __mul
  numBytes += cDelay_init(this, &cDelay_XSmTcSC1, 0.0f);
  numBytes += cDelay_init(this, &cDelay_pDIGPhjJ, 0.0f);
  numBytes += hTable_init(&hTable_RQkgAERq, 256);
  numBytes += cVar_init_f(&cVar_SEZ4VjpC, 0.0f);
  numBytes += cVar_init_f(&cVar_W0akXWRy, 0.0f);
  numBytes += cVar_init_f(&cVar_fQgeYZ23, 0.0f);
  numBytes += cVar_init_f(&cVar_VnBDaCLo, 0.0f);
  numBytes += cVar_init_s(&cVar_XMZRreVm, "del-del");
  numBytes += sVarf_init(&sVarf_1XPUT766, 0.0f, 0.0f, false);
  numBytes += sVarf_init(&sVarf_Puoj2QPe, 0.0f, 0.0f, false);
  numBytes += sVarf_init(&sVarf_b7By7QIh, 0.0f, 0.0f, false);
  numBytes += cVar_init_f(&cVar_wcCP0NJi, 1.0f);
  numBytes += cSlice_init(&cSlice_Fw1uajNs, 2, 1);
  numBytes += cSlice_init(&cSlice_YW3QKnTq, 1, 1);
  numBytes += cSlice_init(&cSlice_AfFvCgf9, 0, 1);
  numBytes += cBinop_init(&cBinop_oimVaEsO, 1.0f); // __pow
  numBytes += cBinop_init(&cBinop_hesyA8Yg, 0.0f); // __add
  numBytes += sVarf_init(&sVarf_7lIBPjgU, 0.3f, 0.0f, false);
  
  // schedule a message to trigger all loadbangs via the __hv_init receiver
  scheduleMessageForReceiver(0xCE5CC65B, msg_initWithBang(HV_MESSAGE_ON_STACK(1), 0));
}

Heavy_arp_delay_env::~Heavy_arp_delay_env() {
  hTable_free(&hTable_RQkgAERq);
}

HvTable *Heavy_arp_delay_env::getTableForHash(hv_uint32_t tableHash) {switch (tableHash) {
    case 0x7BAC8768: return &hTable_RQkgAERq; // del-del
    default: return nullptr;
  }
}

void Heavy_arp_delay_env::scheduleMessageForReceiver(hv_uint32_t receiverHash, HvMessage *m) {
  switch (receiverHash) {
    case 0x40ADE322: { // Arp_Pitch
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_XUCgPiDD_sendMessage);
      break;
    }
    case 0x234E72EF: { // Arp_Speed
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_EcfMX78P_sendMessage);
      break;
    }
    case 0x53767352: { // Delay_Repeats
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_GkgEZDwE_sendMessage);
      break;
    }
    case 0xEE78D101: { // Delay_Time
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_4Kzf4FZT_sendMessage);
      break;
    }
    case 0xCE5CC65B: { // __hv_init
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_mK4YUsJl_sendMessage);
      break;
    }
    case 0x67E37CA3: { // __hv_notein
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_eXrF3UlG_sendMessage);
      break;
    }
    default: return;
  }
}

int Heavy_arp_delay_env::getParameterInfo(int index, HvParameterInfo *info) {
  if (info != nullptr) {
    switch (index) {
      case 0: {
        info->name = "Arp_Pitch";
        info->hash = 0x40ADE322;
        info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
        info->minVal = 0.0f;
        info->maxVal = 1.0f;
        info->defaultVal = 0.5f;
        break;
      }
      case 1: {
        info->name = "Arp_Speed";
        info->hash = 0x234E72EF;
        info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
        info->minVal = 0.0f;
        info->maxVal = 1.0f;
        info->defaultVal = 0.5f;
        break;
      }
      case 2: {
        info->name = "Delay_Repeats";
        info->hash = 0x53767352;
        info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
        info->minVal = 0.0f;
        info->maxVal = 1.0f;
        info->defaultVal = 0.5f;
        break;
      }
      case 3: {
        info->name = "Delay_Time";
        info->hash = 0xEE78D101;
        info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
        info->minVal = 0.0f;
        info->maxVal = 1.0f;
        info->defaultVal = 0.5f;
        break;
      }
      default: {
        info->name = "invalid parameter index";
        info->hash = 0;
        info->type = HvParameterType::HV_PARAM_TYPE_PARAMETER_IN;
        info->minVal = 0.0f;
        info->maxVal = 0.0f;
        info->defaultVal = 0.0f;
        break;
      }
    }
  }
  return 4;
}



/*
 * Send Function Implementations
 */


void Heavy_arp_delay_env::cVar_QpNfcxTV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_onMessage(_c, &Context(_c)->cBinop_hesyA8Yg, HV_BINOP_ADD, 1, m, &cBinop_hesyA8Yg_sendMessage);
}

void Heavy_arp_delay_env::cSwitchcase_JEjQ8389_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x3F800000: { // "1.0"
      cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_zerZuBAj_sendMessage);
      break;
    }
    default: {
      break;
    }
  }
}

void Heavy_arp_delay_env::cCast_zerZuBAj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_A0C5qwHZ_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::cSwitchcase_MAHWLSLi_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x0: { // "0.0"
      cMsg_EIFIlHRW_sendMessage(_c, 0, m);
      break;
    }
    case 0x7A5B032D: { // "stop"
      cMsg_EIFIlHRW_sendMessage(_c, 0, m);
      break;
    }
    default: {
      cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_hpcdUgv0_sendMessage);
      break;
    }
  }
}

void Heavy_arp_delay_env::cDelay_TiC320ze_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
  cDelay_clearExecutingMessage(&Context(_c)->cDelay_TiC320ze, m);
  cDelay_onMessage(_c, &Context(_c)->cDelay_TiC320ze, 0, m, &cDelay_TiC320ze_sendMessage);
  cMsg_qVR4M6qt_sendMessage(_c, 0, m);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_79XmGDKd_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_xyQ6QCqj_sendMessage);
}

void Heavy_arp_delay_env::cCast_hpcdUgv0_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_EIFIlHRW_sendMessage(_c, 0, m);
  cDelay_onMessage(_c, &Context(_c)->cDelay_TiC320ze, 0, m, &cDelay_TiC320ze_sendMessage);
  cMsg_qVR4M6qt_sendMessage(_c, 0, m);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_79XmGDKd_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_xyQ6QCqj_sendMessage);
}

void Heavy_arp_delay_env::cMsg_nEreHrAN_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setSymbol(m, 0, "samplerate");
  cSystem_onMessage(_c, NULL, 0, m, &cSystem_f2BGea9a_sendMessage);
}

void Heavy_arp_delay_env::cSystem_f2BGea9a_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_IvE42sSb_sendMessage);
}

void Heavy_arp_delay_env::cVar_BG8d1bMD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_onMessage(_c, &Context(_c)->cBinop_aL2oj1zg, HV_BINOP_MULTIPLY, 0, m, &cBinop_aL2oj1zg_sendMessage);
}

void Heavy_arp_delay_env::cMsg_EIFIlHRW_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setSymbol(m, 0, "clear");
  cDelay_onMessage(_c, &Context(_c)->cDelay_TiC320ze, 0, m, &cDelay_TiC320ze_sendMessage);
}

void Heavy_arp_delay_env::cBinop_N9H9NawL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cDelay_onMessage(_c, &Context(_c)->cDelay_TiC320ze, 2, m, &cDelay_TiC320ze_sendMessage);
}

void Heavy_arp_delay_env::cBinop_IvE42sSb_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_onMessage(_c, &Context(_c)->cBinop_aL2oj1zg, HV_BINOP_MULTIPLY, 1, m, &cBinop_aL2oj1zg_sendMessage);
}

void Heavy_arp_delay_env::cBinop_aL2oj1zg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 1.0f, 0, m, &cBinop_N9H9NawL_sendMessage);
}

void Heavy_arp_delay_env::cMsg_fVpsf0EY_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setSymbol(m, 0, "samplerate");
  cSystem_onMessage(_c, NULL, 0, m, &cSystem_qdiBBSrT_sendMessage);
}

void Heavy_arp_delay_env::cSystem_qdiBBSrT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_D578FYDj_sendMessage);
}

void Heavy_arp_delay_env::cDelay_XSmTcSC1_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
  cDelay_clearExecutingMessage(&Context(_c)->cDelay_XSmTcSC1, m);
  cDelay_onMessage(_c, &Context(_c)->cDelay_pDIGPhjJ, 0, m, &cDelay_pDIGPhjJ_sendMessage);
  cDelay_onMessage(_c, &Context(_c)->cDelay_XSmTcSC1, 0, m, &cDelay_XSmTcSC1_sendMessage);
  sTabwrite_onMessage(_c, &Context(_c)->sTabwrite_lra5KFKD, 1, m, NULL);
}

void Heavy_arp_delay_env::cDelay_pDIGPhjJ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
  cDelay_clearExecutingMessage(&Context(_c)->cDelay_pDIGPhjJ, m);
  cMsg_8Jd91u4J_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::cBinop_a6xP9f6r_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_L8kmBApX_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::hTable_RQkgAERq_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_jjqDeWpg_sendMessage(_c, 0, m);
  cDelay_onMessage(_c, &Context(_c)->cDelay_XSmTcSC1, 2, m, &cDelay_XSmTcSC1_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_TyQ72s6o_sendMessage);
}

void Heavy_arp_delay_env::cMsg_L8kmBApX_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(2);
  msg_init(m, 2, msg_getTimestamp(n));
  msg_setSymbol(m, 0, "resize");
  msg_setElementToFrom(m, 1, n, 0);
  hTable_onMessage(_c, &Context(_c)->hTable_RQkgAERq, 0, m, &hTable_RQkgAERq_sendMessage);
}

void Heavy_arp_delay_env::cBinop_D578FYDj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_a6xP9f6r_sendMessage);
}

void Heavy_arp_delay_env::cMsg_8Jd91u4J_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setSymbol(m, 0, "mirror");
  hTable_onMessage(_c, &Context(_c)->hTable_RQkgAERq, 0, m, &hTable_RQkgAERq_sendMessage);
}

void Heavy_arp_delay_env::cCast_TyQ72s6o_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cDelay_onMessage(_c, &Context(_c)->cDelay_XSmTcSC1, 0, m, &cDelay_XSmTcSC1_sendMessage);
}

void Heavy_arp_delay_env::cMsg_jjqDeWpg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setFloat(m, 0,  static_cast<float>(HV_N_SIMD));
  cDelay_onMessage(_c, &Context(_c)->cDelay_pDIGPhjJ, 2, m, &cDelay_pDIGPhjJ_sendMessage);
}

void Heavy_arp_delay_env::cVar_SEZ4VjpC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_rnkTCEOE_sendMessage);
}

void Heavy_arp_delay_env::cVar_W0akXWRy_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_86yU2trO_sendMessage);
}

void Heavy_arp_delay_env::cVar_fQgeYZ23_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 600.0f, 0, m, &cBinop_b7c8uTvL_sendMessage);
}

void Heavy_arp_delay_env::cVar_VnBDaCLo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sVarf_onMessage(_c, &Context(_c)->sVarf_7lIBPjgU, m);
}

void Heavy_arp_delay_env::cMsg_AusRai4k_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setSymbol(m, 0, "samplerate");
  cSystem_onMessage(_c, NULL, 0, m, &cSystem_1GtyEzxF_sendMessage);
}

void Heavy_arp_delay_env::cSystem_1GtyEzxF_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_D7aI6oLJ_sendMessage);
}

void Heavy_arp_delay_env::cVar_XMZRreVm_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_u7DQ67Ug_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::cSystem_NStX9wYa_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 1.0f, 0, m, &cBinop_dhfHyNRX_sendMessage);
  sVarf_onMessage(_c, &Context(_c)->sVarf_1XPUT766, m);
}

void Heavy_arp_delay_env::cBinop_D7aI6oLJ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sVarf_onMessage(_c, &Context(_c)->sVarf_Puoj2QPe, m);
}

void Heavy_arp_delay_env::cMsg_u7DQ67Ug_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(3);
  msg_init(m, 3, msg_getTimestamp(n));
  msg_setSymbol(m, 0, "table");
  msg_setElementToFrom(m, 1, n, 0);
  msg_setSymbol(m, 2, "size");
  cSystem_onMessage(_c, NULL, 0, m, &cSystem_NStX9wYa_sendMessage);
}

void Heavy_arp_delay_env::cBinop_dhfHyNRX_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sVarf_onMessage(_c, &Context(_c)->sVarf_b7By7QIh, m);
}

void Heavy_arp_delay_env::cVar_wcCP0NJi_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sLine_onMessage(_c, &Context(_c)->sLine_tLkWSR92, 0, m, NULL);
}

void Heavy_arp_delay_env::cSlice_Fw1uajNs_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

void Heavy_arp_delay_env::cSlice_YW3QKnTq_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

void Heavy_arp_delay_env::cSlice_AfFvCgf9_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 69.0f, 0, m, &cBinop_Pt69l6DW_sendMessage);
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

void Heavy_arp_delay_env::cBinop_BY849OFM_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sPhasor_k_onMessage(_c, &Context(_c)->sPhasor_deMq4ELY, 0, m);
}

void Heavy_arp_delay_env::cBinop_Pt69l6DW_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 12.0f, 0, m, &cBinop_x27TkP5A_sendMessage);
}

void Heavy_arp_delay_env::cBinop_x27TkP5A_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_onMessage(_c, &Context(_c)->cBinop_oimVaEsO, HV_BINOP_POW, 1, m, &cBinop_oimVaEsO_sendMessage);
  cMsg_Y0D08wrf_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::cBinop_oimVaEsO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_BY849OFM_sendMessage);
}

void Heavy_arp_delay_env::cMsg_Y0D08wrf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setFloat(m, 0, 2.0f);
  cBinop_onMessage(_c, &Context(_c)->cBinop_oimVaEsO, HV_BINOP_POW, 0, m, &cBinop_oimVaEsO_sendMessage);
}

void Heavy_arp_delay_env::cBinop_hesyA8Yg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_QpNfcxTV, 0, m, &cVar_QpNfcxTV_sendMessage);
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 4.0f, 0, m, &cBinop_QamkPGUu_sendMessage);
}

void Heavy_arp_delay_env::cMsg_qVR4M6qt_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setFloat(m, 0, 1.0f);
  cBinop_onMessage(_c, &Context(_c)->cBinop_hesyA8Yg, HV_BINOP_ADD, 0, m, &cBinop_hesyA8Yg_sendMessage);
}

void Heavy_arp_delay_env::cMsg_A0C5qwHZ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setFloat(m, 0, 0.0f);
  cVar_onMessage(_c, &Context(_c)->cVar_QpNfcxTV, 0, m, &cVar_QpNfcxTV_sendMessage);
}

void Heavy_arp_delay_env::cMsg_6yCKZYJD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setFloat(m, 0, 1.0f);
  cSwitchcase_MAHWLSLi_onMessage(_c, NULL, 0, m, NULL);
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_rnkTCEOE_sendMessage);
}

void Heavy_arp_delay_env::cMsg_fDDSBI42_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setFloat(m, 0, 0.3f);
  sVarf_onMessage(_c, &Context(_c)->sVarf_7lIBPjgU, m);
}

void Heavy_arp_delay_env::cBinop_86yU2trO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
}

void Heavy_arp_delay_env::cMsg_XJFOKNQO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setFloat(m, 0, 440.0f);
}

void Heavy_arp_delay_env::cMsg_g5DX3UAM_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(1);
  msg_init(m, 1, msg_getTimestamp(n));
  msg_setFloat(m, 0, 220.0f);
  cMsg_5K6Ff69g_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::cBinop_b7c8uTvL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_ADD, 20.0f, 0, m, &cBinop_exCKzhjC_sendMessage);
}

void Heavy_arp_delay_env::cBinop_exCKzhjC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_5K6Ff69g_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::cBinop_QamkPGUu_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSwitchcase_JEjQ8389_onMessage(_c, NULL, 0, m, NULL);
}

void Heavy_arp_delay_env::cBinop_rnkTCEOE_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_BG8d1bMD, 0, m, &cVar_BG8d1bMD_sendMessage);
}

void Heavy_arp_delay_env::cMsg_5K6Ff69g_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(2);
  msg_init(m, 2, msg_getTimestamp(n));
  msg_setElementToFrom(m, 0, n, 0);
  msg_setFloat(m, 1, 20.0f);
  sLine_onMessage(_c, &Context(_c)->sLine_5Jrovr0w, 0, m, NULL);
}

void Heavy_arp_delay_env::cMsg_T2Vn5l1r_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const n) {
  HvMessage *m = nullptr;
  m = HV_MESSAGE_ON_STACK(2);
  msg_init(m, 2, msg_getTimestamp(n));
  msg_setFloat(m, 0, 0.0f);
  msg_setFloat(m, 1, 300.0f);
  sLine_onMessage(_c, &Context(_c)->sLine_tLkWSR92, 0, m, NULL);
}

void Heavy_arp_delay_env::cCast_xyQ6QCqj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_T2Vn5l1r_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::cCast_79XmGDKd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_wcCP0NJi, 0, m, &cVar_wcCP0NJi_sendMessage);
}

void Heavy_arp_delay_env::cReceive_mK4YUsJl_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_nEreHrAN_sendMessage(_c, 0, m);
  cVar_onMessage(_c, &Context(_c)->cVar_BG8d1bMD, 0, m, &cVar_BG8d1bMD_sendMessage);
  cMsg_fVpsf0EY_sendMessage(_c, 0, m);
  cMsg_6yCKZYJD_sendMessage(_c, 0, m);
  cMsg_fDDSBI42_sendMessage(_c, 0, m);
  cMsg_XJFOKNQO_sendMessage(_c, 0, m);
  cMsg_g5DX3UAM_sendMessage(_c, 0, m);
  cVar_onMessage(_c, &Context(_c)->cVar_XMZRreVm, 0, m, &cVar_XMZRreVm_sendMessage);
  cMsg_AusRai4k_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env::cReceive_eXrF3UlG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSlice_onMessage(_c, &Context(_c)->cSlice_Fw1uajNs, 0, m, &cSlice_Fw1uajNs_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_YW3QKnTq, 0, m, &cSlice_YW3QKnTq_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_AfFvCgf9, 0, m, &cSlice_AfFvCgf9_sendMessage);
}

void Heavy_arp_delay_env::cReceive_GkgEZDwE_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sVarf_onMessage(_c, &Context(_c)->sVarf_7lIBPjgU, m);
}

void Heavy_arp_delay_env::cReceive_XUCgPiDD_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_86yU2trO_sendMessage);
}

void Heavy_arp_delay_env::cReceive_EcfMX78P_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_rnkTCEOE_sendMessage);
}

void Heavy_arp_delay_env::cReceive_4Kzf4FZT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 600.0f, 0, m, &cBinop_b7c8uTvL_sendMessage);
}




/*
 * Context Process Implementation
 */

int Heavy_arp_delay_env::process(float **inputBuffers, float **outputBuffers, int n) {
  while (hLp_hasData(&inQueue)) {
    hv_uint32_t numBytes = 0;
    ReceiverMessagePair *p = reinterpret_cast<ReceiverMessagePair *>(hLp_getReadBuffer(&inQueue, &numBytes));
    hv_assert(numBytes >= sizeof(ReceiverMessagePair));
    scheduleMessageForReceiver(p->receiverHash, &p->msg);
    hLp_consume(&inQueue);
  }
  const int n4 = n & ~HV_N_SIMD_MASK; // ensure that the block size is a multiple of HV_N_SIMD

  // temporary signal vars
  hv_bufferf_t Bf0, Bf1, Bf2, Bf3, Bf4, Bf5, Bf6;
  hv_bufferi_t Bi0, Bi1;

  // input and output vars
  hv_bufferf_t O0, O1;

  // declare and init the zero buffer
  hv_bufferf_t ZERO; __hv_zero_f(VOf(ZERO));

  hv_uint32_t nextBlock = blockStartTimestamp;
  for (int n = 0; n < n4; n += HV_N_SIMD) {

    // process all of the messages for this block
    nextBlock += HV_N_SIMD;
    while (mq_hasMessageBefore(&mq, nextBlock)) {
      MessageNode *const node = mq_peek(&mq);
      node->sendMessage(this, node->let, node->m);
      mq_pop(&mq);
    }

    

    // zero output buffers
    __hv_zero_f(VOf(O0));
    __hv_zero_f(VOf(O1));

    // process all signal functions
    __hv_line_f(&sLine_5Jrovr0w, VOf(Bf0));
    __hv_tabhead_f(&sTabhead_5flIzcsR, VOf(Bf1));
    __hv_var_k_f_r(VOf(Bf2), -1.0f, -2.0f, -3.0f, -4.0f, -5.0f, -6.0f, -7.0f, -8.0f);
    __hv_add_f(VIf(Bf1), VIf(Bf2), VOf(Bf2));
    __hv_varread_f(&sVarf_Puoj2QPe, VOf(Bf1));
    __hv_mul_f(VIf(Bf0), VIf(Bf1), VOf(Bf1));
    __hv_varread_f(&sVarf_b7By7QIh, VOf(Bf0));
    __hv_min_f(VIf(Bf1), VIf(Bf0), VOf(Bf0));
    __hv_zero_f(VOf(Bf1));
    __hv_max_f(VIf(Bf0), VIf(Bf1), VOf(Bf1));
    __hv_sub_f(VIf(Bf2), VIf(Bf1), VOf(Bf1));
    __hv_floor_f(VIf(Bf1), VOf(Bf2));
    __hv_varread_f(&sVarf_1XPUT766, VOf(Bf0));
    __hv_zero_f(VOf(Bf3));
    __hv_lt_f(VIf(Bf2), VIf(Bf3), VOf(Bf3));
    __hv_and_f(VIf(Bf0), VIf(Bf3), VOf(Bf3));
    __hv_add_f(VIf(Bf2), VIf(Bf3), VOf(Bf3));
    __hv_cast_fi(VIf(Bf3), VOi(Bi0));
    __hv_var_k_i(VOi(Bi1), 1, 1, 1, 1, 1, 1, 1, 1);
    __hv_add_i(VIi(Bi0), VIi(Bi1), VOi(Bi1));
    __hv_tabread_if(&sTabread_3ztnQBI7, VIi(Bi1), VOf(Bf3));
    __hv_tabread_if(&sTabread_Va5jECJY, VIi(Bi0), VOf(Bf0));
    __hv_sub_f(VIf(Bf3), VIf(Bf0), VOf(Bf3));
    __hv_sub_f(VIf(Bf1), VIf(Bf2), VOf(Bf2));
    __hv_fma_f(VIf(Bf3), VIf(Bf2), VIf(Bf0), VOf(Bf0));
    __hv_varread_f(&sVarf_7lIBPjgU, VOf(Bf2));
    __hv_phasor_k_f(&sPhasor_deMq4ELY, VOf(Bf3));
    __hv_var_k_f(VOf(Bf1), 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f);
    __hv_sub_f(VIf(Bf3), VIf(Bf1), VOf(Bf1));
    __hv_abs_f(VIf(Bf1), VOf(Bf1));
    __hv_var_k_f(VOf(Bf3), 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f, 0.25f);
    __hv_sub_f(VIf(Bf1), VIf(Bf3), VOf(Bf3));
    __hv_var_k_f(VOf(Bf1), 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f, 6.283185307179586f);
    __hv_mul_f(VIf(Bf3), VIf(Bf1), VOf(Bf1));
    __hv_mul_f(VIf(Bf1), VIf(Bf1), VOf(Bf3));
    __hv_mul_f(VIf(Bf1), VIf(Bf3), VOf(Bf4));
    __hv_mul_f(VIf(Bf4), VIf(Bf3), VOf(Bf3));
    __hv_var_k_f(VOf(Bf5), 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f, 0.007833333333333f);
    __hv_var_k_f(VOf(Bf6), -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f, -0.166666666666667f);
    __hv_fma_f(VIf(Bf4), VIf(Bf6), VIf(Bf1), VOf(Bf1));
    __hv_fma_f(VIf(Bf3), VIf(Bf5), VIf(Bf1), VOf(Bf1));
    __hv_line_f(&sLine_tLkWSR92, VOf(Bf5));
    __hv_mul_f(VIf(Bf1), VIf(Bf5), VOf(Bf5));
    __hv_fma_f(VIf(Bf0), VIf(Bf2), VIf(Bf5), VOf(Bf2));
    __hv_tabwrite_f(&sTabwrite_lra5KFKD, VIf(Bf2));
    __hv_add_f(VIf(Bf5), VIf(Bf0), VOf(Bf0));
    __hv_var_k_f(VOf(Bf5), 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f);
    __hv_mul_f(VIf(Bf0), VIf(Bf5), VOf(Bf5));
    __hv_add_f(VIf(Bf5), VIf(O1), VOf(O1));
    __hv_add_f(VIf(Bf5), VIf(O0), VOf(O0));

    // save output vars to output buffer
    __hv_store_f(outputBuffers[0]+n, VIf(O0));
    __hv_store_f(outputBuffers[1]+n, VIf(O1));
  }

  blockStartTimestamp = nextBlock;

  return n4; // return the number of frames processed
}

int Heavy_arp_delay_env::processInline(float *inputBuffers, float *outputBuffers, int n4) {
  hv_assert(!(n4 & HV_N_SIMD_MASK)); // ensure that n4 is a multiple of HV_N_SIMD

  // define the heavy input buffer for 0 channel(s)
  float **const bIn = NULL;

  // define the heavy output buffer for 2 channel(s)
  float **const bOut = reinterpret_cast<float **>(hv_alloca(2*sizeof(float *)));
  bOut[0] = outputBuffers+(0*n4);
  bOut[1] = outputBuffers+(1*n4);

  int n = process(bIn, bOut, n4);
  return n;
}

int Heavy_arp_delay_env::processInlineInterleaved(float *inputBuffers, float *outputBuffers, int n4) {
  hv_assert(n4 & ~HV_N_SIMD_MASK); // ensure that n4 is a multiple of HV_N_SIMD

  // define the heavy input buffer for 0 channel(s), uninterleave
  float *const bIn = NULL;

  // define the heavy output buffer for 2 channel(s)
  float *const bOut = reinterpret_cast<float *>(hv_alloca(2*n4*sizeof(float)));

  int n = processInline(bIn, bOut, n4);

  // interleave the heavy output into the output buffer
  #if HV_SIMD_AVX
  for (int i = 0, j = 0; j < n4; j += 8, i += 16) {
    __m256 x = _mm256_load_ps(bOut+j);    // LLLLLLLL
    __m256 y = _mm256_load_ps(bOut+n4+j); // RRRRRRRR
    __m256 a = _mm256_unpacklo_ps(x, y);  // LRLRLRLR
    __m256 b = _mm256_unpackhi_ps(x, y);  // LRLRLRLR
    _mm256_store_ps(outputBuffers+i, a);
    _mm256_store_ps(outputBuffers+8+i, b);
  }
  #elif HV_SIMD_SSE
  for (int i = 0, j = 0; j < n4; j += 4, i += 8) {
    __m128 x = _mm_load_ps(bOut+j);    // LLLL
    __m128 y = _mm_load_ps(bOut+n4+j); // RRRR
    __m128 a = _mm_unpacklo_ps(x, y);  // LRLR
    __m128 b = _mm_unpackhi_ps(x, y);  // LRLR
    _mm_store_ps(outputBuffers+i, a);
    _mm_store_ps(outputBuffers+4+i, b);
  }
  #elif HV_SIMD_NEON
  // https://community.arm.com/groups/processors/blog/2012/03/13/coding-for-neon--part-5-rearranging-vectors
  for (int i = 0, j = 0; j < n4; j += 4, i += 8) {
    float32x4_t x = vld1q_f32(bOut+j);
    float32x4_t y = vld1q_f32(bOut+n4+j);
    float32x4x2_t z = {x, y};
    vst2q_f32(outputBuffers+i, z); // interleave and store
  }
  #else // HV_SIMD_NONE
  for (int i = 0; i < 2; ++i) {
    for (int j = 0; j < n4; ++j) {
      outputBuffers[i+2*j] = bOut[i*n4+j];
    }
  }
  #endif

  return n;
}