/**
 * 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_pd.hpp"

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



/*
 * C Functions
 */

extern "C" {
  HV_EXPORT HeavyContextInterface *hv_arp_delay_env_pd_new(double sampleRate) {
    return new Heavy_arp_delay_env_pd(sampleRate);
  }

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







/*
 * Class Functions
 */

Heavy_arp_delay_env_pd::Heavy_arp_delay_env_pd(double sampleRate, int poolKb, int inQueueKb, int outQueueKb)
    : HeavyContext(sampleRate, poolKb, inQueueKb, outQueueKb) {
  numBytes += sLine_init(&sLine_CPk6VuuC);
  numBytes += sTabhead_init(&sTabhead_Ccf3pWD1, &hTable_ncKDzzLt);
  numBytes += sTabread_init(&sTabread_AIPPIP2p, &hTable_ncKDzzLt, false);
  numBytes += sTabread_init(&sTabread_OR6AChVH, &hTable_ncKDzzLt, false);
  numBytes += sPhasor_k_init(&sPhasor_p4d5TEqg, 220.0f, sampleRate);
  numBytes += sLine_init(&sLine_GYQ4PLNT);
  numBytes += sTabwrite_init(&sTabwrite_qOQtZKqp, &hTable_ncKDzzLt);
  numBytes += cVar_init_f(&cVar_YvPEpnUh, 1.0f);
  numBytes += cVar_init_f(&cVar_eHayjBv6, 0.0f);
  numBytes += cDelay_init(this, &cDelay_DYnzHpic, 0.0f);
  numBytes += cVar_init_f(&cVar_hj1UO5Xy, 300.0f);
  numBytes += cBinop_init(&cBinop_sPNudZ6R, 0.0f); // __mul
  numBytes += cVar_init_f(&cVar_XXw3dChu, 0.0f);
  numBytes += cVar_init_f(&cVar_SLtg6rNc, 0.0f);
  numBytes += cVar_init_f(&cVar_YIxdPCGV, 0.0f);
  numBytes += cVar_init_s(&cVar_ssKQAxko, "del-del");
  numBytes += sVarf_init(&sVarf_NKFEO8VS, 0.0f, 0.0f, false);
  numBytes += sVarf_init(&sVarf_TJn8TVJj, 0.0f, 0.0f, false);
  numBytes += sVarf_init(&sVarf_0ophamek, 0.0f, 0.0f, false);
  numBytes += cDelay_init(this, &cDelay_X79tuCf2, 0.0f);
  numBytes += cDelay_init(this, &cDelay_hlwCH2uT, 0.0f);
  numBytes += hTable_init(&hTable_ncKDzzLt, 256);
  numBytes += cVar_init_f(&cVar_AF7niKwq, 0.0f);
  numBytes += cBinop_init(&cBinop_0qRwCHv8, 150.0f); // __mul
  numBytes += sVarf_init(&sVarf_mi6YMKiN, 0.3f, 0.0f, false);
  numBytes += cBinop_init(&cBinop_m5zjVpQA, 0.0f); // __add
  
  // 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_pd::~Heavy_arp_delay_env_pd() {
  hTable_free(&hTable_ncKDzzLt);
}

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

void Heavy_arp_delay_env_pd::scheduleMessageForReceiver(hv_uint32_t receiverHash, HvMessage *m) {
  switch (receiverHash) {
    case 0x79853B03: { // Channel_A
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_dWWIm2kL_sendMessage);
      break;
    }
    case 0xE16E1682: { // Channel_B
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_vkMNq8T0_sendMessage);
      break;
    }
    case 0xE72718FC: { // Channel_C
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_LPnclThz_sendMessage);
      break;
    }
    case 0x307C0274: { // Channel_D
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_9w5JwN59_sendMessage);
      break;
    }
    case 0xCE5CC65B: { // __hv_init
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_E1RLP07b_sendMessage);
      break;
    }
    default: return;
  }
}

int Heavy_arp_delay_env_pd::getParameterInfo(int index, HvParameterInfo *info) {
  if (info != nullptr) {
    switch (index) {
      case 0: {
        info->name = "Channel_A";
        info->hash = 0x79853B03;
        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 = "Channel_B";
        info->hash = 0xE16E1682;
        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 = "Channel_C";
        info->hash = 0xE72718FC;
        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 = "Channel_D";
        info->hash = 0x307C0274;
        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_pd::cVar_YvPEpnUh_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sLine_onMessage(_c, &Context(_c)->sLine_GYQ4PLNT, 0, m, NULL);
}

void Heavy_arp_delay_env_pd::cVar_eHayjBv6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_CwzvBF2s_sendMessage);
}

void Heavy_arp_delay_env_pd::cDelay_DYnzHpic_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
  cDelay_clearExecutingMessage(&Context(_c)->cDelay_DYnzHpic, m);
  cDelay_onMessage(_c, &Context(_c)->cDelay_DYnzHpic, 0, m, &cDelay_DYnzHpic_sendMessage);
  cMsg_BQRg6jNP_sendMessage(_c, 0, m);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_GKFWiStO_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_0XRxEH1C_sendMessage);
}

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

void Heavy_arp_delay_env_pd::cCast_gzZa7okE_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_E4Ec6do0_sendMessage(_c, 0, m);
  cDelay_onMessage(_c, &Context(_c)->cDelay_DYnzHpic, 0, m, &cDelay_DYnzHpic_sendMessage);
  cMsg_BQRg6jNP_sendMessage(_c, 0, m);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_GKFWiStO_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_0XRxEH1C_sendMessage);
}

void Heavy_arp_delay_env_pd::cVar_hj1UO5Xy_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_onMessage(_c, &Context(_c)->cBinop_sPNudZ6R, HV_BINOP_MULTIPLY, 0, m, &cBinop_sPNudZ6R_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_xUl3JuzU_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_pBUNmntT_sendMessage);
}

void Heavy_arp_delay_env_pd::cSystem_pBUNmntT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_d9vmQ0rR_sendMessage);
}

void Heavy_arp_delay_env_pd::cBinop_sPNudZ6R_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 1.0f, 0, m, &cBinop_G3zRyasr_sendMessage);
}

void Heavy_arp_delay_env_pd::cBinop_d9vmQ0rR_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_onMessage(_c, &Context(_c)->cBinop_sPNudZ6R, HV_BINOP_MULTIPLY, 1, m, &cBinop_sPNudZ6R_sendMessage);
}

void Heavy_arp_delay_env_pd::cBinop_G3zRyasr_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cDelay_onMessage(_c, &Context(_c)->cDelay_DYnzHpic, 2, m, &cDelay_DYnzHpic_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_E4Ec6do0_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_DYnzHpic, 0, m, &cDelay_DYnzHpic_sendMessage);
}

void Heavy_arp_delay_env_pd::cVar_XXw3dChu_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_onMessage(_c, &Context(_c)->cBinop_m5zjVpQA, HV_BINOP_ADD, 1, m, &cBinop_m5zjVpQA_sendMessage);
}

void Heavy_arp_delay_env_pd::cVar_SLtg6rNc_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_puVbRaHY_sendMessage);
}

void Heavy_arp_delay_env_pd::cVar_YIxdPCGV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 600.0f, 0, m, &cBinop_9OkU32H1_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_Zqip7Xkd_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_zehWpnU4_sendMessage);
}

void Heavy_arp_delay_env_pd::cSystem_zehWpnU4_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_qGBikGct_sendMessage);
}

void Heavy_arp_delay_env_pd::cVar_ssKQAxko_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_qfTfqBM3_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env_pd::cBinop_s01cENlp_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sVarf_onMessage(_c, &Context(_c)->sVarf_0ophamek, m);
}

void Heavy_arp_delay_env_pd::cBinop_qGBikGct_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sVarf_onMessage(_c, &Context(_c)->sVarf_NKFEO8VS, m);
}

void Heavy_arp_delay_env_pd::cMsg_qfTfqBM3_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_4oKrr4xn_sendMessage);
}

void Heavy_arp_delay_env_pd::cSystem_4oKrr4xn_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 1.0f, 0, m, &cBinop_s01cENlp_sendMessage);
  sVarf_onMessage(_c, &Context(_c)->sVarf_TJn8TVJj, m);
}

void Heavy_arp_delay_env_pd::cDelay_X79tuCf2_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
  cDelay_clearExecutingMessage(&Context(_c)->cDelay_X79tuCf2, m);
  cMsg_ae7TxKOA_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env_pd::cDelay_hlwCH2uT_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *const m) {
  cDelay_clearExecutingMessage(&Context(_c)->cDelay_hlwCH2uT, m);
  cDelay_onMessage(_c, &Context(_c)->cDelay_X79tuCf2, 0, m, &cDelay_X79tuCf2_sendMessage);
  cDelay_onMessage(_c, &Context(_c)->cDelay_hlwCH2uT, 0, m, &cDelay_hlwCH2uT_sendMessage);
  sTabwrite_onMessage(_c, &Context(_c)->sTabwrite_qOQtZKqp, 1, m, NULL);
}

void Heavy_arp_delay_env_pd::cMsg_MxJmfWRW_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_rAf0fyDp_sendMessage);
}

void Heavy_arp_delay_env_pd::cSystem_rAf0fyDp_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_DIVIDE, 1000.0f, 0, m, &cBinop_8GCNF1V8_sendMessage);
}

void Heavy_arp_delay_env_pd::cBinop_ET5EQCTg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_3up8OQvv_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env_pd::cBinop_8GCNF1V8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_ET5EQCTg_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_3up8OQvv_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_ncKDzzLt, 0, m, &hTable_ncKDzzLt_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_icWX8ifl_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_X79tuCf2, 2, m, &cDelay_X79tuCf2_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_ae7TxKOA_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_ncKDzzLt, 0, m, &hTable_ncKDzzLt_sendMessage);
}

void Heavy_arp_delay_env_pd::hTable_ncKDzzLt_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_icWX8ifl_sendMessage(_c, 0, m);
  cDelay_onMessage(_c, &Context(_c)->cDelay_hlwCH2uT, 2, m, &cDelay_hlwCH2uT_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_Wzlb1WzU_sendMessage);
}

void Heavy_arp_delay_env_pd::cCast_Wzlb1WzU_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cDelay_onMessage(_c, &Context(_c)->cDelay_hlwCH2uT, 0, m, &cDelay_hlwCH2uT_sendMessage);
}

void Heavy_arp_delay_env_pd::cVar_AF7niKwq_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sVarf_onMessage(_c, &Context(_c)->sVarf_mi6YMKiN, m);
}

void Heavy_arp_delay_env_pd::cCast_zvxvkeYa_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_5N2semj0_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env_pd::cSwitchcase_mEf8Naqe_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_zvxvkeYa_sendMessage);
      break;
    }
    default: {
      break;
    }
  }
}

void Heavy_arp_delay_env_pd::cBinop_0qRwCHv8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sPhasor_k_onMessage(_c, &Context(_c)->sPhasor_p4d5TEqg, 0, m);
}

void Heavy_arp_delay_env_pd::cBinop_CwzvBF2s_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_onMessage(_c, &Context(_c)->cBinop_0qRwCHv8, HV_BINOP_MULTIPLY, 1, m, &cBinop_0qRwCHv8_sendMessage);
}

void Heavy_arp_delay_env_pd::cBinop_9OkU32H1_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_ADD, 20.0f, 0, m, &cBinop_vc0hK7tw_sendMessage);
}

void Heavy_arp_delay_env_pd::cBinop_puVbRaHY_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_hj1UO5Xy, 0, m, &cVar_hj1UO5Xy_sendMessage);
}

void Heavy_arp_delay_env_pd::cBinop_m5zjVpQA_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_XXw3dChu, 0, m, &cVar_XXw3dChu_sendMessage);
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 4.0f, 0, m, &cBinop_GJqnOqJV_sendMessage);
  cBinop_onMessage(_c, &Context(_c)->cBinop_0qRwCHv8, HV_BINOP_MULTIPLY, 0, m, &cBinop_0qRwCHv8_sendMessage);
}

void Heavy_arp_delay_env_pd::cBinop_vc0hK7tw_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_tM3dKBd6_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env_pd::cBinop_GJqnOqJV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSwitchcase_mEf8Naqe_onMessage(_c, NULL, 0, m, NULL);
}

void Heavy_arp_delay_env_pd::cMsg_0V4UPj7Z_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_GYQ4PLNT, 0, m, NULL);
}

void Heavy_arp_delay_env_pd::cMsg_jOD5Mj4Q_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_O5mYhl3b_onMessage(_c, NULL, 0, m, NULL);
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_puVbRaHY_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_dmrzMGJf_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_mi6YMKiN, m);
}

void Heavy_arp_delay_env_pd::cMsg_hPlGDhkM_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);
  cBinop_onMessage(_c, &Context(_c)->cBinop_0qRwCHv8, HV_BINOP_MULTIPLY, 1, m, &cBinop_0qRwCHv8_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_tM3dKBd6_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_CPk6VuuC, 0, m, NULL);
}

void Heavy_arp_delay_env_pd::cMsg_2SqJZJHs_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_tM3dKBd6_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env_pd::cMsg_5N2semj0_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_XXw3dChu, 0, m, &cVar_XXw3dChu_sendMessage);
}

void Heavy_arp_delay_env_pd::cMsg_BQRg6jNP_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_m5zjVpQA, HV_BINOP_ADD, 0, m, &cBinop_m5zjVpQA_sendMessage);
}

void Heavy_arp_delay_env_pd::cCast_0XRxEH1C_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_0V4UPj7Z_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env_pd::cCast_GKFWiStO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_YvPEpnUh, 0, m, &cVar_YvPEpnUh_sendMessage);
}

void Heavy_arp_delay_env_pd::cReceive_E1RLP07b_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cMsg_xUl3JuzU_sendMessage(_c, 0, m);
  cVar_onMessage(_c, &Context(_c)->cVar_hj1UO5Xy, 0, m, &cVar_hj1UO5Xy_sendMessage);
  cMsg_MxJmfWRW_sendMessage(_c, 0, m);
  cMsg_jOD5Mj4Q_sendMessage(_c, 0, m);
  cMsg_dmrzMGJf_sendMessage(_c, 0, m);
  cMsg_hPlGDhkM_sendMessage(_c, 0, m);
  cMsg_2SqJZJHs_sendMessage(_c, 0, m);
  cVar_onMessage(_c, &Context(_c)->cVar_ssKQAxko, 0, m, &cVar_ssKQAxko_sendMessage);
  cMsg_Zqip7Xkd_sendMessage(_c, 0, m);
}

void Heavy_arp_delay_env_pd::cReceive_LPnclThz_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 600.0f, 0, m, &cBinop_9OkU32H1_sendMessage);
}

void Heavy_arp_delay_env_pd::cReceive_dWWIm2kL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 1000.0f, 0, m, &cBinop_puVbRaHY_sendMessage);
}

void Heavy_arp_delay_env_pd::cReceive_vkMNq8T0_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MULTIPLY, 440.0f, 0, m, &cBinop_CwzvBF2s_sendMessage);
}

void Heavy_arp_delay_env_pd::cReceive_9w5JwN59_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  sVarf_onMessage(_c, &Context(_c)->sVarf_mi6YMKiN, m);
}




/*
 * Context Process Implementation
 */

int Heavy_arp_delay_env_pd::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_CPk6VuuC, VOf(Bf0));
    __hv_tabhead_f(&sTabhead_Ccf3pWD1, 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_NKFEO8VS, VOf(Bf1));
    __hv_mul_f(VIf(Bf0), VIf(Bf1), VOf(Bf1));
    __hv_varread_f(&sVarf_0ophamek, 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_TJn8TVJj, 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_AIPPIP2p, VIi(Bi1), VOf(Bf3));
    __hv_tabread_if(&sTabread_OR6AChVH, 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_mi6YMKiN, VOf(Bf2));
    __hv_phasor_k_f(&sPhasor_p4d5TEqg, 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_GYQ4PLNT, 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_qOQtZKqp, 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(O0), VOf(O0));
    __hv_add_f(VIf(Bf5), VIf(O1), VOf(O1));

    // 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_pd::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_pd::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;
}