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

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



/*
 * C Functions
 */

extern "C" {
  HV_EXPORT HeavyContextInterface *hv_dpf_midi_thru_new(double sampleRate) {
    return new Heavy_dpf_midi_thru(sampleRate);
  }

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







/*
 * Class Functions
 */

Heavy_dpf_midi_thru::Heavy_dpf_midi_thru(double sampleRate, int poolKb, int inQueueKb, int outQueueKb)
    : HeavyContext(sampleRate, poolKb, inQueueKb, outQueueKb) {
  numBytes += cSlice_init(&cSlice_v5VrmQ3B, 2, 1);
  numBytes += cSlice_init(&cSlice_B6GSlADW, 1, 1);
  numBytes += cSlice_init(&cSlice_I2zcuRMh, 0, 1);
  numBytes += cSlice_init(&cSlice_aQFkp8jd, 1, -1);
  numBytes += cSlice_init(&cSlice_pXycK95c, 1, -1);
  numBytes += cVar_init_f(&cVar_SsXGQ3yt, 0.0f);
  numBytes += cIf_init(&cIf_QAMfCGlA, false);
  numBytes += cVar_init_f(&cVar_bgKXntSO, 0.0f);
  numBytes += cIf_init(&cIf_XUqD69Wm, false);
  numBytes += cIf_init(&cIf_xeEFtXrE, false);
  numBytes += cIf_init(&cIf_blvp4MGy, false);
  numBytes += cIf_init(&cIf_YpXJceX5, false);
  numBytes += cIf_init(&cIf_pv0z1hoC, false);
  numBytes += cPack_init(&cPack_zLmFzaLK, 3, 0.0f, 0.0f, 0.0f);
  numBytes += cVar_init_f(&cVar_6D7wQ3Az, 0.0f);
  numBytes += cVar_init_f(&cVar_MJKwDHLB, 0.0f);
  numBytes += cSlice_init(&cSlice_YtUwtXzp, 2, 1);
  numBytes += cSlice_init(&cSlice_4bqP2oLK, 1, 1);
  numBytes += cSlice_init(&cSlice_1SuRmnmd, 0, 1);
  numBytes += cSlice_init(&cSlice_3EDBlgeL, 1, -1);
  numBytes += cSlice_init(&cSlice_GYdZztDQ, 1, -1);
  numBytes += cVar_init_f(&cVar_NI8bIuKu, 0.0f);
  numBytes += cIf_init(&cIf_7cTQGOoF, false);
  numBytes += cVar_init_f(&cVar_f62oZqD1, 0.0f);
  numBytes += cIf_init(&cIf_crhcV6aG, false);
  numBytes += cIf_init(&cIf_4MsIOXwd, false);
  numBytes += cIf_init(&cIf_IP20Rt2h, false);
  numBytes += cIf_init(&cIf_hXRe9EOe, false);
  numBytes += cIf_init(&cIf_PNrClbNB, false);
  numBytes += cPack_init(&cPack_eHhFaSnZ, 3, 0.0f, 0.0f, 0.0f);
  numBytes += cVar_init_f(&cVar_9eKlV0De, 0.0f);
  numBytes += cVar_init_f(&cVar_R4oWcxfc, 0.0f);
  numBytes += cSlice_init(&cSlice_Rp6eSPzC, 1, 1);
  numBytes += cSlice_init(&cSlice_b66IORBq, 0, 1);
  numBytes += cSlice_init(&cSlice_BwwzIXZ3, 1, -1);
  numBytes += cVar_init_f(&cVar_uEvC9ivd, 0.0f);
  numBytes += cIf_init(&cIf_f7N9mpfj, false);
  numBytes += cIf_init(&cIf_lqz1DeIQ, false);
  numBytes += cPack_init(&cPack_OCgqfLze, 2, 0.0f, 0.0f);
  numBytes += cVar_init_f(&cVar_QInLDlgx, 0.0f);
  numBytes += cSlice_init(&cSlice_awhatFOB, 1, 1);
  numBytes += cSlice_init(&cSlice_PtdAXHV5, 0, 1);
  numBytes += cSlice_init(&cSlice_0McvQ7qW, 1, -1);
  numBytes += cVar_init_f(&cVar_jyDV1rnb, 0.0f);
  numBytes += cIf_init(&cIf_TsLbu4r1, false);
  numBytes += cIf_init(&cIf_gH5ngjJa, false);
  numBytes += cPack_init(&cPack_h7p6RmaV, 2, 0.0f, 0.0f);
  numBytes += cVar_init_f(&cVar_OvPqjfDo, 0.0f);
  numBytes += cSlice_init(&cSlice_HunsaH1W, 1, 1);
  numBytes += cSlice_init(&cSlice_yers4e0I, 0, 1);
  numBytes += cSlice_init(&cSlice_QUQUSCFN, 1, -1);
  numBytes += cVar_init_f(&cVar_I3zJO9MH, 0.0f);
  numBytes += cIf_init(&cIf_0I956Cig, false);
  numBytes += cIf_init(&cIf_FkWw7KyS, false);
  numBytes += cPack_init(&cPack_bP9Q0y6Y, 2, 0.0f, 0.0f);
  numBytes += cVar_init_f(&cVar_ZJHvrRhO, 0.0f);
  
  // schedule a message to trigger all loadbangs via the __hv_init receiver
  scheduleMessageForReceiver(0xCE5CC65B, msg_initWithBang(HV_MESSAGE_ON_STACK(1), 0));
}

Heavy_dpf_midi_thru::~Heavy_dpf_midi_thru() {
  cPack_free(&cPack_zLmFzaLK);
  cPack_free(&cPack_eHhFaSnZ);
  cPack_free(&cPack_OCgqfLze);
  cPack_free(&cPack_h7p6RmaV);
  cPack_free(&cPack_bP9Q0y6Y);
}

HvTable *Heavy_dpf_midi_thru::getTableForHash(hv_uint32_t tableHash) {
  return nullptr;
}

void Heavy_dpf_midi_thru::scheduleMessageForReceiver(hv_uint32_t receiverHash, HvMessage *m) {
  switch (receiverHash) {
    case 0x3083F0F7: { // __hv_bendin
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_m1A6DpHC_sendMessage);
      break;
    }
    case 0x41BE0F9C: { // __hv_ctlin
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_kfgVicPa_sendMessage);
      break;
    }
    case 0xCE5CC65B: { // __hv_init
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_vVXNu8wl_sendMessage);
      break;
    }
    case 0x67E37CA3: { // __hv_notein
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_WNrV9V4X_sendMessage);
      break;
    }
    case 0x2E1EA03D: { // __hv_pgmin
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_fyIDjcGp_sendMessage);
      break;
    }
    case 0x553925BD: { // __hv_touchin
      mq_addMessageByTimestamp(&mq, m, 0, &cReceive_h3jgrtHh_sendMessage);
      break;
    }
    default: return;
  }
}

int Heavy_dpf_midi_thru::getParameterInfo(int index, HvParameterInfo *info) {
  if (info != nullptr) {
    switch (index) {
      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 0;
}



/*
 * Send Function Implementations
 */


void Heavy_dpf_midi_thru::cSlice_v5VrmQ3B_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cVar_onMessage(_c, &Context(_c)->cVar_MJKwDHLB, 0, m, &cVar_MJKwDHLB_sendMessage);
      cIf_onMessage(_c, &Context(_c)->cIf_xeEFtXrE, 0, m, &cIf_xeEFtXrE_sendMessage);
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cSlice_B6GSlADW_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cIf_onMessage(_c, &Context(_c)->cIf_pv0z1hoC, 0, m, &cIf_pv0z1hoC_sendMessage);
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

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

void Heavy_dpf_midi_thru::cSwitchcase_CjUUBW5B_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x0: { // "0.0"
      cSlice_onMessage(_c, &Context(_c)->cSlice_aQFkp8jd, 0, m, &cSlice_aQFkp8jd_sendMessage);
      break;
    }
    default: {
      cMsg_rek2TsVl_sendMessage(_c, 0, m);
      break;
    }
  }
}

void Heavy_dpf_midi_thru::cSlice_aQFkp8jd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cSwitchcase_jkq5Pl2Q_onMessage(_c, NULL, 0, m, NULL);
      break;
    }
    case 1: {
      cSwitchcase_jkq5Pl2Q_onMessage(_c, NULL, 0, m, NULL);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cSwitchcase_jkq5Pl2Q_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x0: { // "0.0"
      cSlice_onMessage(_c, &Context(_c)->cSlice_pXycK95c, 0, m, &cSlice_pXycK95c_sendMessage);
      break;
    }
    default: {
      cMsg_0XGa3vEW_sendMessage(_c, 0, m);
      break;
    }
  }
}

void Heavy_dpf_midi_thru::cSlice_pXycK95c_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cPack_onMessage(_c, &Context(_c)->cPack_zLmFzaLK, 0, m, &cPack_zLmFzaLK_sendMessage);
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_zLmFzaLK, 0, m, &cPack_zLmFzaLK_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cVar_SsXGQ3yt_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_Acuy1sJf_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_QAMfCGlA, 0, m, &cIf_QAMfCGlA_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_brjdPpjr_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_qWl4QOMG_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_xeEFtXrE, 1, m, &cIf_xeEFtXrE_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_BFrAK30i_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_qWl4QOMG_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_xeEFtXrE, 1, m, &cIf_xeEFtXrE_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_QAMfCGlA_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_BFrAK30i_sendMessage);
      break;
    }
    case 1: {
      cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_brjdPpjr_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_Acuy1sJf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_QAMfCGlA, 1, m, &cIf_QAMfCGlA_sendMessage);
}

void Heavy_dpf_midi_thru::cVar_bgKXntSO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_EAHDuvw9_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_XUqD69Wm, 0, m, &cIf_XUqD69Wm_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_jhize0RL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_3KNHgmEB_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_wMrSZ8Bn_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_3KNHgmEB_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_XUqD69Wm_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_wMrSZ8Bn_sendMessage);
      break;
    }
    case 1: {
      cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_jhize0RL_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_EAHDuvw9_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_XUqD69Wm, 1, m, &cIf_XUqD69Wm_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_xeEFtXrE_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cVar_onMessage(_c, &Context(_c)->cVar_6D7wQ3Az, 0, m, &cVar_6D7wQ3Az_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cIf_blvp4MGy_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_zLmFzaLK, 0, m, &cPack_zLmFzaLK_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cIf_YpXJceX5_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_zLmFzaLK, 0, m, &cPack_zLmFzaLK_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cIf_pv0z1hoC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cVar_onMessage(_c, &Context(_c)->cVar_6D7wQ3Az, 0, m, &cVar_6D7wQ3Az_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_3KNHgmEB_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_blvp4MGy, 1, m, &cIf_blvp4MGy_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_qWl4QOMG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_YpXJceX5, 1, m, &cIf_YpXJceX5_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_pv0z1hoC, 1, m, &cIf_pv0z1hoC_sendMessage);
}

void Heavy_dpf_midi_thru::cMsg_Mzc2I5WZ_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_setElementToFrom(m, 0, n, 1);
  msg_setElementToFrom(m, 1, n, 2);
  msg_setElementToFrom(m, 2, n, 0);
  cSwitchcase_CjUUBW5B_onMessage(_c, NULL, 0, m, NULL);
}

void Heavy_dpf_midi_thru::cMsg_rek2TsVl_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_setElementToFrom(m, 0, n, 2);
  cIf_onMessage(_c, &Context(_c)->cIf_YpXJceX5, 0, m, &cIf_YpXJceX5_sendMessage);
}

void Heavy_dpf_midi_thru::cMsg_0XGa3vEW_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_setElementToFrom(m, 0, n, 1);
  cIf_onMessage(_c, &Context(_c)->cIf_blvp4MGy, 0, m, &cIf_blvp4MGy_sendMessage);
}

void Heavy_dpf_midi_thru::cPack_zLmFzaLK_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSend_JTXcgFsy_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cBinop_JfBQFHlI_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_n7hvyxeQ_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_n7hvyxeQ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cPack_onMessage(_c, &Context(_c)->cPack_zLmFzaLK, 2, m, &cPack_zLmFzaLK_sendMessage);
}

void Heavy_dpf_midi_thru::cVar_6D7wQ3Az_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cPack_onMessage(_c, &Context(_c)->cPack_zLmFzaLK, 1, m, &cPack_zLmFzaLK_sendMessage);
}

void Heavy_dpf_midi_thru::cVar_MJKwDHLB_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_JfBQFHlI_sendMessage);
}

void Heavy_dpf_midi_thru::cSend_JTXcgFsy_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_noteout", 0xD1D4AC2, m);
}

void Heavy_dpf_midi_thru::cCast_JrReKUYu_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_6D7wQ3Az, 0, m, &cVar_6D7wQ3Az_sendMessage);
}

void Heavy_dpf_midi_thru::cCast_cjNOB9Vf_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_MJKwDHLB, 0, m, &cVar_MJKwDHLB_sendMessage);
}

void Heavy_dpf_midi_thru::cSlice_YtUwtXzp_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cVar_onMessage(_c, &Context(_c)->cVar_9eKlV0De, 0, m, &cVar_9eKlV0De_sendMessage);
      cIf_onMessage(_c, &Context(_c)->cIf_4MsIOXwd, 0, m, &cIf_4MsIOXwd_sendMessage);
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cSlice_4bqP2oLK_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cIf_onMessage(_c, &Context(_c)->cIf_PNrClbNB, 0, m, &cIf_PNrClbNB_sendMessage);
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

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

void Heavy_dpf_midi_thru::cSwitchcase_4wHAp26q_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x0: { // "0.0"
      cSlice_onMessage(_c, &Context(_c)->cSlice_3EDBlgeL, 0, m, &cSlice_3EDBlgeL_sendMessage);
      break;
    }
    default: {
      cMsg_3sBhN5km_sendMessage(_c, 0, m);
      break;
    }
  }
}

void Heavy_dpf_midi_thru::cSlice_3EDBlgeL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cSwitchcase_THn7YVaK_onMessage(_c, NULL, 0, m, NULL);
      break;
    }
    case 1: {
      cSwitchcase_THn7YVaK_onMessage(_c, NULL, 0, m, NULL);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cSwitchcase_THn7YVaK_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x0: { // "0.0"
      cSlice_onMessage(_c, &Context(_c)->cSlice_GYdZztDQ, 0, m, &cSlice_GYdZztDQ_sendMessage);
      break;
    }
    default: {
      cMsg_nf3YyE0C_sendMessage(_c, 0, m);
      break;
    }
  }
}

void Heavy_dpf_midi_thru::cSlice_GYdZztDQ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cPack_onMessage(_c, &Context(_c)->cPack_eHhFaSnZ, 0, m, &cPack_eHhFaSnZ_sendMessage);
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_eHhFaSnZ, 0, m, &cPack_eHhFaSnZ_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cVar_NI8bIuKu_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_WkQHTU3S_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_7cTQGOoF, 0, m, &cIf_7cTQGOoF_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_juM4e16P_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_dFGMUkFY_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_4MsIOXwd, 1, m, &cIf_4MsIOXwd_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_GkNnhKKB_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_dFGMUkFY_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_4MsIOXwd, 1, m, &cIf_4MsIOXwd_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_7cTQGOoF_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_GkNnhKKB_sendMessage);
      break;
    }
    case 1: {
      cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_juM4e16P_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_WkQHTU3S_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_7cTQGOoF, 1, m, &cIf_7cTQGOoF_sendMessage);
}

void Heavy_dpf_midi_thru::cVar_f62oZqD1_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_dvnYPvdb_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_crhcV6aG, 0, m, &cIf_crhcV6aG_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_p9eKj59r_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_jaJIJvy8_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_GWW3YUhc_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_jaJIJvy8_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_crhcV6aG_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_GWW3YUhc_sendMessage);
      break;
    }
    case 1: {
      cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_p9eKj59r_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_dvnYPvdb_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_crhcV6aG, 1, m, &cIf_crhcV6aG_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_4MsIOXwd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cVar_onMessage(_c, &Context(_c)->cVar_R4oWcxfc, 0, m, &cVar_R4oWcxfc_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cIf_IP20Rt2h_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_eHhFaSnZ, 0, m, &cPack_eHhFaSnZ_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cIf_hXRe9EOe_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_eHhFaSnZ, 0, m, &cPack_eHhFaSnZ_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cIf_PNrClbNB_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cVar_onMessage(_c, &Context(_c)->cVar_R4oWcxfc, 0, m, &cVar_R4oWcxfc_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_jaJIJvy8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_IP20Rt2h, 1, m, &cIf_IP20Rt2h_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_dFGMUkFY_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_hXRe9EOe, 1, m, &cIf_hXRe9EOe_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_PNrClbNB, 1, m, &cIf_PNrClbNB_sendMessage);
}

void Heavy_dpf_midi_thru::cMsg_5dGKgdVQ_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_setElementToFrom(m, 0, n, 1);
  msg_setElementToFrom(m, 1, n, 2);
  msg_setElementToFrom(m, 2, n, 0);
  cSwitchcase_4wHAp26q_onMessage(_c, NULL, 0, m, NULL);
}

void Heavy_dpf_midi_thru::cMsg_3sBhN5km_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_setElementToFrom(m, 0, n, 2);
  cIf_onMessage(_c, &Context(_c)->cIf_hXRe9EOe, 0, m, &cIf_hXRe9EOe_sendMessage);
}

void Heavy_dpf_midi_thru::cMsg_nf3YyE0C_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_setElementToFrom(m, 0, n, 1);
  cIf_onMessage(_c, &Context(_c)->cIf_IP20Rt2h, 0, m, &cIf_IP20Rt2h_sendMessage);
}

void Heavy_dpf_midi_thru::cPack_eHhFaSnZ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSend_QvD6c9AQ_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cVar_9eKlV0De_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_t6a5BR8F_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_t6a5BR8F_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_W5ijg6A8_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_W5ijg6A8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cPack_onMessage(_c, &Context(_c)->cPack_eHhFaSnZ, 2, m, &cPack_eHhFaSnZ_sendMessage);
}

void Heavy_dpf_midi_thru::cVar_R4oWcxfc_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cPack_onMessage(_c, &Context(_c)->cPack_eHhFaSnZ, 1, m, &cPack_eHhFaSnZ_sendMessage);
}

void Heavy_dpf_midi_thru::cSend_QvD6c9AQ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_ctlout", 0xE5E2A040, m);
}

void Heavy_dpf_midi_thru::cCast_S6pjFYdg_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_9eKlV0De, 0, m, &cVar_9eKlV0De_sendMessage);
}

void Heavy_dpf_midi_thru::cCast_r4TRulVk_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_R4oWcxfc, 0, m, &cVar_R4oWcxfc_sendMessage);
}

void Heavy_dpf_midi_thru::cSlice_Rp6eSPzC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cVar_onMessage(_c, &Context(_c)->cVar_QInLDlgx, 0, m, &cVar_QInLDlgx_sendMessage);
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

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

void Heavy_dpf_midi_thru::cSwitchcase_N3kP8wKC_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x0: { // "0.0"
      cSlice_onMessage(_c, &Context(_c)->cSlice_BwwzIXZ3, 0, m, &cSlice_BwwzIXZ3_sendMessage);
      break;
    }
    default: {
      cMsg_QjGuPskp_sendMessage(_c, 0, m);
      break;
    }
  }
}

void Heavy_dpf_midi_thru::cSlice_BwwzIXZ3_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cPack_onMessage(_c, &Context(_c)->cPack_OCgqfLze, 0, m, &cPack_OCgqfLze_sendMessage);
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_OCgqfLze, 0, m, &cPack_OCgqfLze_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cVar_uEvC9ivd_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_ldtCVbeL_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_f7N9mpfj, 0, m, &cIf_f7N9mpfj_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_wy6EQvmX_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_QXGiNqI0_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_Vhpg6Qog_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_QXGiNqI0_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_f7N9mpfj_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_Vhpg6Qog_sendMessage);
      break;
    }
    case 1: {
      cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_wy6EQvmX_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_ldtCVbeL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_f7N9mpfj, 1, m, &cIf_f7N9mpfj_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_lqz1DeIQ_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_OCgqfLze, 0, m, &cPack_OCgqfLze_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_QXGiNqI0_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_lqz1DeIQ, 1, m, &cIf_lqz1DeIQ_sendMessage);
}

void Heavy_dpf_midi_thru::cMsg_3spmcwwH_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, 1);
  msg_setElementToFrom(m, 1, n, 0);
  cSwitchcase_N3kP8wKC_onMessage(_c, NULL, 0, m, NULL);
}

void Heavy_dpf_midi_thru::cMsg_QjGuPskp_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_setElementToFrom(m, 0, n, 0);
  cIf_onMessage(_c, &Context(_c)->cIf_lqz1DeIQ, 0, m, &cIf_lqz1DeIQ_sendMessage);
}

void Heavy_dpf_midi_thru::cPack_OCgqfLze_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSend_Uq11MpZC_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cVar_QInLDlgx_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_mLhoNBZ6_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_mLhoNBZ6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_2TbgR5IC_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_2TbgR5IC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cPack_onMessage(_c, &Context(_c)->cPack_OCgqfLze, 1, m, &cPack_OCgqfLze_sendMessage);
}

void Heavy_dpf_midi_thru::cSend_Uq11MpZC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_pgmout", 0x8753E39E, m);
}

void Heavy_dpf_midi_thru::cSlice_awhatFOB_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cVar_onMessage(_c, &Context(_c)->cVar_OvPqjfDo, 0, m, &cVar_OvPqjfDo_sendMessage);
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

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

void Heavy_dpf_midi_thru::cSwitchcase_qy900BDR_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x0: { // "0.0"
      cSlice_onMessage(_c, &Context(_c)->cSlice_0McvQ7qW, 0, m, &cSlice_0McvQ7qW_sendMessage);
      break;
    }
    default: {
      cMsg_1qDkeSh2_sendMessage(_c, 0, m);
      break;
    }
  }
}

void Heavy_dpf_midi_thru::cSlice_0McvQ7qW_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cPack_onMessage(_c, &Context(_c)->cPack_h7p6RmaV, 0, m, &cPack_h7p6RmaV_sendMessage);
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_h7p6RmaV, 0, m, &cPack_h7p6RmaV_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cVar_jyDV1rnb_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_4jDoWsCi_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_TsLbu4r1, 0, m, &cIf_TsLbu4r1_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_4nK6YYA5_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_t4oPyIE5_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_78VYx19V_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_t4oPyIE5_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_TsLbu4r1_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_78VYx19V_sendMessage);
      break;
    }
    case 1: {
      cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_4nK6YYA5_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_4jDoWsCi_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_TsLbu4r1, 1, m, &cIf_TsLbu4r1_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_gH5ngjJa_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cPack_onMessage(_c, &Context(_c)->cPack_h7p6RmaV, 0, m, &cPack_h7p6RmaV_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_t4oPyIE5_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_gH5ngjJa, 1, m, &cIf_gH5ngjJa_sendMessage);
}

void Heavy_dpf_midi_thru::cMsg_naImCBzK_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, 1);
  msg_setElementToFrom(m, 1, n, 0);
  cSwitchcase_qy900BDR_onMessage(_c, NULL, 0, m, NULL);
}

void Heavy_dpf_midi_thru::cMsg_1qDkeSh2_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_setElementToFrom(m, 0, n, 0);
  cIf_onMessage(_c, &Context(_c)->cIf_gH5ngjJa, 0, m, &cIf_gH5ngjJa_sendMessage);
}

void Heavy_dpf_midi_thru::cPack_h7p6RmaV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSend_IQu3ImZw_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cVar_OvPqjfDo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_H56XMtw8_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_H56XMtw8_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_0HTJpCDo_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_0HTJpCDo_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cPack_onMessage(_c, &Context(_c)->cPack_h7p6RmaV, 1, m, &cPack_h7p6RmaV_sendMessage);
}

void Heavy_dpf_midi_thru::cSend_IQu3ImZw_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_touchout", 0x476D4387, m);
}

void Heavy_dpf_midi_thru::cSlice_HunsaH1W_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cVar_onMessage(_c, &Context(_c)->cVar_ZJHvrRhO, 0, m, &cVar_ZJHvrRhO_sendMessage);
      break;
    }
    case 1: {
      break;
    }
    default: return;
  }
}

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

void Heavy_dpf_midi_thru::cSwitchcase_PTbwlEdk_onMessage(HeavyContextInterface *_c, void *o, int letIn, const HvMessage *const m, void *sendMessage) {
  switch (msg_getHash(m, 0)) {
    case 0x0: { // "0.0"
      cSlice_onMessage(_c, &Context(_c)->cSlice_QUQUSCFN, 0, m, &cSlice_QUQUSCFN_sendMessage);
      break;
    }
    default: {
      cMsg_0RuBKNIx_sendMessage(_c, 0, m);
      break;
    }
  }
}

void Heavy_dpf_midi_thru::cSlice_QUQUSCFN_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 8192.0f, 0, m, &cBinop_RC576MtY_sendMessage);
      break;
    }
    case 1: {
      cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 8192.0f, 0, m, &cBinop_RC576MtY_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cVar_I3zJO9MH_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_GREATER_THAN, 0.0f, 0, m, &cBinop_FLv4NU6N_sendMessage);
  cIf_onMessage(_c, &Context(_c)->cIf_0I956Cig, 0, m, &cIf_0I956Cig_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_875t5doe_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_0JOLxOL6_sendMessage);
}

void Heavy_dpf_midi_thru::cUnop_8tS95pEp_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_EQ, 0.0f, 0, m, &cBinop_0JOLxOL6_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_0I956Cig_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      cUnop_onMessage(_c, HV_UNOP_CEIL, m, &cUnop_8tS95pEp_sendMessage);
      break;
    }
    case 1: {
      cUnop_onMessage(_c, HV_UNOP_FLOOR, m, &cUnop_875t5doe_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_FLv4NU6N_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_0I956Cig, 1, m, &cIf_0I956Cig_sendMessage);
}

void Heavy_dpf_midi_thru::cIf_FkWw7KyS_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  switch (letIn) {
    case 0: {
      break;
    }
    case 1: {
      cBinop_k_onMessage(_c, NULL, HV_BINOP_SUBTRACT, 8192.0f, 0, m, &cBinop_RC576MtY_sendMessage);
      break;
    }
    default: return;
  }
}

void Heavy_dpf_midi_thru::cBinop_0JOLxOL6_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cIf_onMessage(_c, &Context(_c)->cIf_FkWw7KyS, 1, m, &cIf_FkWw7KyS_sendMessage);
}

void Heavy_dpf_midi_thru::cMsg_3IEkvJhx_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, 1);
  msg_setElementToFrom(m, 1, n, 0);
  cSwitchcase_PTbwlEdk_onMessage(_c, NULL, 0, m, NULL);
}

void Heavy_dpf_midi_thru::cMsg_0RuBKNIx_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_setElementToFrom(m, 0, n, 0);
  cIf_onMessage(_c, &Context(_c)->cIf_FkWw7KyS, 0, m, &cIf_FkWw7KyS_sendMessage);
}

void Heavy_dpf_midi_thru::cPack_bP9Q0y6Y_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSend_hOrNPrno_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cVar_ZJHvrRhO_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MIN, 15.0f, 0, m, &cBinop_X891Gf8Q_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_X891Gf8Q_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_MAX, 0.0f, 0, m, &cBinop_m6mSjIoV_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_m6mSjIoV_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cPack_onMessage(_c, &Context(_c)->cPack_bP9Q0y6Y, 1, m, &cPack_bP9Q0y6Y_sendMessage);
}

void Heavy_dpf_midi_thru::cSend_hOrNPrno_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  if (_c->getSendHook() != nullptr) _c->getSendHook()(_c, "__hv_bendout", 0xE8458013, m);
}

void Heavy_dpf_midi_thru::cBinop_oRGZQosL_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cPack_onMessage(_c, &Context(_c)->cPack_bP9Q0y6Y, 0, m, &cPack_bP9Q0y6Y_sendMessage);
}

void Heavy_dpf_midi_thru::cBinop_RC576MtY_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cBinop_k_onMessage(_c, NULL, HV_BINOP_ADD, 8192.0f, 0, m, &cBinop_oRGZQosL_sendMessage);
}

void Heavy_dpf_midi_thru::cReceive_vVXNu8wl_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cVar_onMessage(_c, &Context(_c)->cVar_SsXGQ3yt, 0, m, &cVar_SsXGQ3yt_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_bgKXntSO, 0, m, &cVar_bgKXntSO_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_cjNOB9Vf_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_JrReKUYu_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_NI8bIuKu, 0, m, &cVar_NI8bIuKu_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_f62oZqD1, 0, m, &cVar_f62oZqD1_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_S6pjFYdg_sendMessage);
  cCast_onMessage(_c, HV_CAST_BANG, 0, m, &cCast_r4TRulVk_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_uEvC9ivd, 0, m, &cVar_uEvC9ivd_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_QInLDlgx, 0, m, &cVar_QInLDlgx_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_jyDV1rnb, 0, m, &cVar_jyDV1rnb_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_OvPqjfDo, 0, m, &cVar_OvPqjfDo_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_I3zJO9MH, 0, m, &cVar_I3zJO9MH_sendMessage);
  cVar_onMessage(_c, &Context(_c)->cVar_ZJHvrRhO, 0, m, &cVar_ZJHvrRhO_sendMessage);
}

void Heavy_dpf_midi_thru::cReceive_WNrV9V4X_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSlice_onMessage(_c, &Context(_c)->cSlice_v5VrmQ3B, 0, m, &cSlice_v5VrmQ3B_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_B6GSlADW, 0, m, &cSlice_B6GSlADW_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_I2zcuRMh, 0, m, &cSlice_I2zcuRMh_sendMessage);
  cMsg_Mzc2I5WZ_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cReceive_kfgVicPa_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSlice_onMessage(_c, &Context(_c)->cSlice_YtUwtXzp, 0, m, &cSlice_YtUwtXzp_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_4bqP2oLK, 0, m, &cSlice_4bqP2oLK_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_1SuRmnmd, 0, m, &cSlice_1SuRmnmd_sendMessage);
  cMsg_5dGKgdVQ_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cReceive_fyIDjcGp_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSlice_onMessage(_c, &Context(_c)->cSlice_Rp6eSPzC, 0, m, &cSlice_Rp6eSPzC_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_b66IORBq, 0, m, &cSlice_b66IORBq_sendMessage);
  cMsg_3spmcwwH_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cReceive_h3jgrtHh_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSlice_onMessage(_c, &Context(_c)->cSlice_awhatFOB, 0, m, &cSlice_awhatFOB_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_PtdAXHV5, 0, m, &cSlice_PtdAXHV5_sendMessage);
  cMsg_naImCBzK_sendMessage(_c, 0, m);
}

void Heavy_dpf_midi_thru::cReceive_m1A6DpHC_sendMessage(HeavyContextInterface *_c, int letIn, const HvMessage *m) {
  cSlice_onMessage(_c, &Context(_c)->cSlice_HunsaH1W, 0, m, &cSlice_HunsaH1W_sendMessage);
  cSlice_onMessage(_c, &Context(_c)->cSlice_yers4e0I, 0, m, &cSlice_yers4e0I_sendMessage);
  cMsg_3IEkvJhx_sendMessage(_c, 0, m);
}




/*
 * Context Process Implementation
 */

int Heavy_dpf_midi_thru::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);
  }
  
  hv_uint32_t nextBlock = blockStartTimestamp + n;
  while (mq_hasMessageBefore(&mq, nextBlock)) {
    MessageNode *const node = mq_peek(&mq);
    node->sendMessage(this, node->let, node->m);
    mq_pop(&mq);
  }

  blockStartTimestamp = nextBlock;
  return n;
}

int Heavy_dpf_midi_thru::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 0 channel(s)
  float **const bOut = NULL;

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

int Heavy_dpf_midi_thru::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 0 channel(s)
  float *const bOut = NULL;

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

  

  return n;
}