/*

 * BMS.c

 *

 * Code generation for model "BMS".

 *

 * Model version              : 1.15

 * Simulink Coder version : 9.2 (R2019b) 18-Jul-2019

 * C source code generated on : Thu Aug 20 14:49:14 2020

 *

 * Target selection: grt.tlc

 * Note: GRT includes extra infrastructure and instrumentation for prototyping

 * Embedded hardware selection: Intel->x86-64 (Windows64)

 * Code generation objectives: Unspecified

 * Validation result: Not run

 */



#include "rt_logging_mmi.h"

#include "BMS_capi.h"

#include "BMS.h"

#include "BMS_private.h"



/* Block signals (default storage) */

B_BMS_T BMS_B;



/* Continuous states */

X_BMS_T BMS_X;



/* Block states (default storage) */

DW_BMS_T BMS_DW;



/* External inputs (root inport signals with default storage) */

ExtU_BMS_T BMS_U;



/* External outputs (root outports fed by signals with default storage) */

ExtY_BMS_T BMS_Y;



/* Real-time model */

RT_MODEL_BMS_T BMS_M_;

RT_MODEL_BMS_T *const BMS_M = &BMS_M_;



/* Forward declaration for local functions */

static int32_T BMS_thirdOfFive(const real_T v[8], int32_T ia, int32_T ib);

static void BMS_quickselect(real_T v[8], int32_T n, int32_T idx0, int32_T vlen,

  real_T *vn, int32_T *nfirst, int32_T *nlast);

real_T look2_binlxpw(real_T u0, real_T u1, const real_T bp0[], const real_T bp1[],

                     const real_T table[], const uint32_T maxIndex[], uint32_T

                     stride)

{

  real_T frac;

  uint32_T bpIndices[2];

  real_T fractions[2];

  real_T yL_1d;

  uint32_T iRght;

  uint32_T bpIdx;

  uint32_T iLeft;



  /* Column-major Lookup 2-D

     Search method: 'binary'

     Use previous index: 'off'

     Interpolation method: 'Linear point-slope'

     Extrapolation method: 'Linear'

     Use last breakpoint for index at or above upper limit: 'off'

     Remove protection against out-of-range input in generated code: 'off'

   */

  /* Prelookup - Index and Fraction

     Index Search method: 'binary'

     Extrapolation method: 'Linear'

     Use previous index: 'off'

     Use last breakpoint for index at or above upper limit: 'off'

     Remove protection against out-of-range input in generated code: 'off'

   */

  if (u0 <= bp0[0U]) {

    iLeft = 0U;

    frac = (u0 - bp0[0U]) / (bp0[1U] - bp0[0U]);

  } else if (u0 < bp0[maxIndex[0U]]) {

    /* Binary Search */

    bpIdx = maxIndex[0U] >> 1U;

    iLeft = 0U;

    iRght = maxIndex[0U];

    while (iRght - iLeft > 1U) {

      if (u0 < bp0[bpIdx]) {

        iRght = bpIdx;

      } else {

        iLeft = bpIdx;

      }



      bpIdx = (iRght + iLeft) >> 1U;

    }



    frac = (u0 - bp0[iLeft]) / (bp0[iLeft + 1U] - bp0[iLeft]);

  } else {

    iLeft = maxIndex[0U] - 1U;

    frac = (u0 - bp0[maxIndex[0U] - 1U]) / (bp0[maxIndex[0U]] - bp0[maxIndex[0U]

      - 1U]);

  }



  fractions[0U] = frac;

  bpIndices[0U] = iLeft;



  /* Prelookup - Index and Fraction

     Index Search method: 'binary'

     Extrapolation method: 'Linear'

     Use previous index: 'off'

     Use last breakpoint for index at or above upper limit: 'off'

     Remove protection against out-of-range input in generated code: 'off'

   */

  if (u1 <= bp1[0U]) {

    iLeft = 0U;

    frac = (u1 - bp1[0U]) / (bp1[1U] - bp1[0U]);

  } else if (u1 < bp1[maxIndex[1U]]) {

    /* Binary Search */

    bpIdx = maxIndex[1U] >> 1U;

    iLeft = 0U;

    iRght = maxIndex[1U];

    while (iRght - iLeft > 1U) {

      if (u1 < bp1[bpIdx]) {

        iRght = bpIdx;

      } else {

        iLeft = bpIdx;

      }



      bpIdx = (iRght + iLeft) >> 1U;

    }



    frac = (u1 - bp1[iLeft]) / (bp1[iLeft + 1U] - bp1[iLeft]);

  } else {

    iLeft = maxIndex[1U] - 1U;

    frac = (u1 - bp1[maxIndex[1U] - 1U]) / (bp1[maxIndex[1U]] - bp1[maxIndex[1U]

      - 1U]);

  }



  /* Column-major Interpolation 2-D

     Interpolation method: 'Linear point-slope'

     Use last breakpoint for index at or above upper limit: 'off'

     Overflow mode: 'portable wrapping'

   */

  bpIdx = iLeft * stride + bpIndices[0U];

  yL_1d = (table[bpIdx + 1U] - table[bpIdx]) * fractions[0U] + table[bpIdx];

  bpIdx += stride;

  return (((table[bpIdx + 1U] - table[bpIdx]) * fractions[0U] + table[bpIdx]) -

          yL_1d) * frac + yL_1d;

}



real_T look1_binlxpw(real_T u0, const real_T bp0[], const real_T table[],

                     uint32_T maxIndex)

{

  real_T frac;

  uint32_T iRght;

  uint32_T iLeft;

  uint32_T bpIdx;



  /* Column-major Lookup 1-D

     Search method: 'binary'

     Use previous index: 'off'

     Interpolation method: 'Linear point-slope'

     Extrapolation method: 'Linear'

     Use last breakpoint for index at or above upper limit: 'off'

     Remove protection against out-of-range input in generated code: 'off'

   */

  /* Prelookup - Index and Fraction

     Index Search method: 'binary'

     Extrapolation method: 'Linear'

     Use previous index: 'off'

     Use last breakpoint for index at or above upper limit: 'off'

     Remove protection against out-of-range input in generated code: 'off'

   */

  if (u0 <= bp0[0U]) {

    iLeft = 0U;

    frac = (u0 - bp0[0U]) / (bp0[1U] - bp0[0U]);

  } else if (u0 < bp0[maxIndex]) {

    /* Binary Search */

    bpIdx = maxIndex >> 1U;

    iLeft = 0U;

    iRght = maxIndex;

    while (iRght - iLeft > 1U) {

      if (u0 < bp0[bpIdx]) {

        iRght = bpIdx;

      } else {

        iLeft = bpIdx;

      }



      bpIdx = (iRght + iLeft) >> 1U;

    }



    frac = (u0 - bp0[iLeft]) / (bp0[iLeft + 1U] - bp0[iLeft]);

  } else {

    iLeft = maxIndex - 1U;

    frac = (u0 - bp0[maxIndex - 1U]) / (bp0[maxIndex] - bp0[maxIndex - 1U]);

  }



  /* Column-major Interpolation 1-D

     Interpolation method: 'Linear point-slope'

     Use last breakpoint for index at or above upper limit: 'off'

     Overflow mode: 'portable wrapping'

   */

  return (table[iLeft + 1U] - table[iLeft]) * frac + table[iLeft];

}



/*

 * This function updates continuous states using the ODE4 fixed-step

 * solver algorithm

 */

static void rt_ertODEUpdateContinuousStates(RTWSolverInfo *si )

{

  time_T t = rtsiGetT(si);

  time_T tnew = rtsiGetSolverStopTime(si);

  time_T h = rtsiGetStepSize(si);

  real_T *x = rtsiGetContStates(si);

  ODE4_IntgData *id = (ODE4_IntgData *)rtsiGetSolverData(si);

  real_T *y = id->y;

  real_T *f0 = id->f[0];

  real_T *f1 = id->f[1];

  real_T *f2 = id->f[2];

  real_T *f3 = id->f[3];

  real_T temp;

  int_T i;

  int_T nXc = 112;

  rtsiSetSimTimeStep(si,MINOR_TIME_STEP);



  /* Save the state values at time t in y, we'll use x as ynew. */

  (void) memcpy(y, x,

                (uint_T)nXc*sizeof(real_T));



  /* Assumes that rtsiSetT and ModelOutputs are up-to-date */

  /* f0 = f(t,y) */

  rtsiSetdX(si, f0);

  BMS_derivatives();



  /* f1 = f(t + (h/2), y + (h/2)*f0) */

  temp = 0.5 * h;

  for (i = 0; i < nXc; i++) {

    x[i] = y[i] + (temp*f0[i]);

  }



  rtsiSetT(si, t + temp);

  rtsiSetdX(si, f1);

  BMS_output();

  BMS_derivatives();



  /* f2 = f(t + (h/2), y + (h/2)*f1) */

  for (i = 0; i < nXc; i++) {

    x[i] = y[i] + (temp*f1[i]);

  }



  rtsiSetdX(si, f2);

  BMS_output();

  BMS_derivatives();



  /* f3 = f(t + h, y + h*f2) */

  for (i = 0; i < nXc; i++) {

    x[i] = y[i] + (h*f2[i]);

  }



  rtsiSetT(si, tnew);

  rtsiSetdX(si, f3);

  BMS_output();

  BMS_derivatives();



  /* tnew = t + h

     ynew = y + (h/6)*(f0 + 2*f1 + 2*f2 + 2*f3) */

  temp = h / 6.0;

  for (i = 0; i < nXc; i++) {

    x[i] = y[i] + temp*(f0[i] + 2.0*f1[i] + 2.0*f2[i] + f3[i]);

  }



  rtsiSetSimTimeStep(si,MAJOR_TIME_STEP);

}



/*

 * Output and update for atomic system:

 *    '<S5>/dead_band'

 *    '<S5>/dead_band1'

 *    '<S5>/dead_band2'

 *    '<S5>/dead_band3'

 *    '<S5>/dead_band4'

 *    '<S5>/dead_band5'

 *    '<S5>/dead_band6'

 *    '<S5>/dead_band7'

 */

void BMS_dead_band(real_T rtu_u, B_dead_band_BMS_T *localB)

{

  localB->y = (real_T)(fabs(rtu_u) > 0.4) * rtu_u;

}



/* Function for MATLAB Function: '<S2>/median' */

static int32_T BMS_thirdOfFive(const real_T v[8], int32_T ia, int32_T ib)

{

  int32_T im;

  int32_T j4;

  int32_T j5;

  real_T v4;

  real_T v5;

  int32_T b_j1;

  int32_T j2;

  real_T v5_tmp;

  if ((ia == ib) || (ia + 1 == ib)) {

    im = ia;

  } else if ((ia + 2 == ib) || (ia + 3 == ib)) {

    v4 = v[ia - 1];

    if (v4 < v[ia]) {

      v5_tmp = v[ia + 1];

      if (v[ia] < v5_tmp) {

        im = ia + 1;

      } else if (v4 < v5_tmp) {

        im = ia + 2;

      } else {

        im = ia;

      }

    } else {

      v5_tmp = v[ia + 1];

      if (v4 < v5_tmp) {

        im = ia;

      } else if (v[ia] < v5_tmp) {

        im = ia + 2;

      } else {

        im = ia + 1;

      }

    }

  } else {

    v4 = v[ia - 1];

    if (v4 < v[ia]) {

      v5_tmp = v[ia + 1];

      if (v[ia] < v5_tmp) {

        b_j1 = ia;

        j2 = ia;

        im = ia + 2;

      } else if (v4 < v5_tmp) {

        b_j1 = ia;

        j2 = ia + 1;

        im = ia + 1;

      } else {

        b_j1 = ia + 2;

        j2 = ia - 1;

        im = ia + 1;

      }

    } else {

      v5_tmp = v[ia + 1];

      if (v4 < v5_tmp) {

        b_j1 = ia + 1;

        j2 = ia - 1;

        im = ia + 2;

      } else if (v[ia] < v5_tmp) {

        b_j1 = ia + 1;

        j2 = ia + 1;

        im = ia;

      } else {

        b_j1 = ia + 2;

        j2 = ia;

        im = ia;

      }

    }



    j4 = ia;

    j5 = ia + 1;

    v4 = v[ia + 2];

    v5_tmp = v[ia + 3];

    v5 = v5_tmp;

    if (v5_tmp < v4) {

      j4 = ia + 1;

      j5 = ia;

      v5 = v4;

      v4 = v5_tmp;

    }



    if (v5 < v[b_j1 - 1]) {

      im = b_j1;

    } else if (v5 < v[j2]) {

      im = j5 + 3;

    } else if (v4 < v[j2]) {

      im = j2 + 1;

    } else {

      if (v4 < v[im - 1]) {

        im = j4 + 3;

      }

    }

  }



  return im;

}



/* Function for MATLAB Function: '<S2>/median' */

static void BMS_quickselect(real_T v[8], int32_T n, int32_T idx0, int32_T vlen,

  real_T *vn, int32_T *nfirst, int32_T *nlast)

{

  int32_T itarget;

  int32_T ipiv;

  int32_T ia;

  int32_T ib;

  int32_T ifirst;

  int32_T ilast;

  int32_T oldnv;

  boolean_T checkspeed;

  boolean_T isslow;

  real_T b_v[8];

  real_T vref;

  real_T vk;

  int32_T b_nlast;

  int32_T i1;

  int32_T destidx;

  boolean_T exitg1;

  boolean_T guard1 = false;

  if ((n < 1) || (n > vlen)) {

    *vn = (rtNaN);

    *nfirst = 0;

    *nlast = 0;

  } else {

    itarget = (idx0 + n) - 1;

    ipiv = itarget - 1;

    ia = idx0 - 1;

    ib = (idx0 + vlen) - 2;

    ifirst = idx0;

    ilast = ib;

    oldnv = vlen;

    checkspeed = false;

    isslow = false;

    exitg1 = false;

    while ((!exitg1) && (ia + 1 < ib + 1)) {

      memcpy(&b_v[0], &v[0], sizeof(real_T) << 3U);

      vref = v[ipiv];

      b_v[ipiv] = v[ib];

      b_v[ib] = v[ipiv];

      b_nlast = ia;

      ifirst = -1;

      for (ilast = ia; ilast < ib; ilast++) {

        vk = b_v[ilast];

        if (b_v[ilast] == vref) {

          b_v[ilast] = b_v[b_nlast];

          b_v[b_nlast] = vk;

          ifirst++;

          b_nlast++;

        } else {

          if (b_v[ilast] < vref) {

            b_v[ilast] = b_v[b_nlast];

            b_v[b_nlast] = vk;

            b_nlast++;

          }

        }

      }



      b_v[ib] = b_v[b_nlast];

      b_v[b_nlast] = v[ipiv];

      memcpy(&v[0], &b_v[0], sizeof(real_T) << 3U);

      ilast = b_nlast;

      guard1 = false;

      if (itarget <= b_nlast + 1) {

        ifirst = b_nlast - ifirst;

        if (itarget >= ifirst) {

          exitg1 = true;

        } else {

          ib = b_nlast - 1;

          guard1 = true;

        }

      } else {

        ia = b_nlast + 1;

        guard1 = true;

      }



      if (guard1) {

        ipiv = (ib - ia) + 1;

        if (checkspeed) {

          isslow = (ipiv > oldnv / 2);

          oldnv = ipiv;

        }



        checkspeed = !checkspeed;

        if (isslow) {

          while (ipiv > 1) {

            ilast = ipiv / 5;

            b_nlast = ipiv - ilast * 5;

            ipiv = ilast;

            for (ifirst = 0; ifirst < ilast; ifirst++) {

              i1 = (ifirst * 5 + ia) + 1;

              i1 = BMS_thirdOfFive(v, i1, i1 + 4) - 1;

              destidx = ia + ifirst;

              vref = v[destidx];

              v[destidx] = v[i1];

              v[i1] = vref;

            }



            if (b_nlast > 0) {

              i1 = (ilast * 5 + ia) + 1;

              i1 = BMS_thirdOfFive(v, i1, (i1 + b_nlast) - 1) - 1;

              destidx = ia + ilast;

              vref = v[destidx];

              v[destidx] = v[i1];

              v[i1] = vref;

              ipiv = ilast + 1;

            }

          }

        } else {

          if (ipiv >= 3) {

            ipiv = (ipiv - 1) / 2 + ia;

            if (b_v[ia] < b_v[ipiv]) {

              if (b_v[ipiv] < b_v[ib]) {

                ilast = ipiv + 1;

              } else if (b_v[ia] < b_v[ib]) {

                ilast = ib + 1;

              } else {

                ilast = ia + 1;

              }

            } else if (b_v[ia] < b_v[ib]) {

              ilast = ia + 1;

            } else if (b_v[ipiv] < b_v[ib]) {

              ilast = ib + 1;

            } else {

              ilast = ipiv + 1;

            }



            ipiv = ilast - 1;

            if (ipiv + 1 > ia + 1) {

              v[ia] = b_v[ipiv];

              v[ipiv] = b_v[ia];

            }

          }

        }



        ipiv = ia;

        ifirst = ia + 1;

        ilast = ib;

      }

    }



    *vn = v[ilast];

    *nfirst = (ifirst - idx0) + 1;

    *nlast = (ilast - idx0) + 2;

  }

}



/* Model output function */

void BMS_output(void)

{

  int32_T sigIdx;

  real_T v[8];

  int32_T ifirst;

  int32_T unusedU2;

  real_T rtb_Bias;

  real_T rtb_Bias1;

  real_T rtb_Bias2;

  real_T rtb_Divide3;

  real_T rtb_Add8;

  real_T rtb_Product_o2;

  real_T rtb_Sqrt;

  real_T rtb_TransferFcn1;

  real_T rtb_Add7;

  real_T rtb_Add1_o;

  real_T rtb_Add1_c;

  real_T tmpForInput_tmp[8];

  int32_T exitg1;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* set solver stop time */

    if (!(BMS_M->Timing.clockTick0+1)) {

      rtsiSetSolverStopTime(&BMS_M->solverInfo, ((BMS_M->Timing.clockTickH0 + 1)

        * BMS_M->Timing.stepSize0 * 4294967296.0));

    } else {

      rtsiSetSolverStopTime(&BMS_M->solverInfo, ((BMS_M->Timing.clockTick0 + 1) *

        BMS_M->Timing.stepSize0 + BMS_M->Timing.clockTickH0 *

        BMS_M->Timing.stepSize0 * 4294967296.0));

    }

  }                                    /* end MajorTimeStep */



  /* Update absolute time of base rate at minor time step */

  if (rtmIsMinorTimeStep(BMS_M)) {

    BMS_M->Timing.t[0] = rtsiGetT(&BMS_M->solverInfo);

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Outport: '<Root>/Out1' incorporates:

     *  Memory: '<Root>/Memory'

     */

    BMS_Y.Out1 = BMS_DW.Memory_PreviousInput;



    /* Outport: '<Root>/Out2' incorporates:

     *  Memory: '<Root>/Memory1'

     */

    BMS_Y.Out2 = BMS_DW.Memory1_PreviousInput;



    /* Outport: '<Root>/Out3' incorporates:

     *  Memory: '<Root>/Memory2'

     */

    BMS_Y.Out3 = BMS_DW.Memory2_PreviousInput;



    /* Outport: '<Root>/Out4' incorporates:

     *  Memory: '<Root>/Memory3'

     */

    BMS_Y.Out4 = BMS_DW.Memory3_PreviousInput;



    /* Outport: '<Root>/Out5' incorporates:

     *  Memory: '<Root>/Memory4'

     */

    BMS_Y.Out5 = BMS_DW.Memory4_PreviousInput;



    /* Outport: '<Root>/Out6' incorporates:

     *  Memory: '<Root>/Memory5'

     */

    BMS_Y.Out6 = BMS_DW.Memory5_PreviousInput;



    /* Outport: '<Root>/Out7' incorporates:

     *  Memory: '<Root>/Memory6'

     */

    BMS_Y.Out7 = BMS_DW.Memory6_PreviousInput;



    /* Outport: '<Root>/Out8' incorporates:

     *  Memory: '<Root>/Memory7'

     */

    BMS_Y.Out8 = BMS_DW.Memory7_PreviousInput;



    /* Outport: '<Root>/Out9' incorporates:

     *  Memory: '<Root>/Memory8'

     */

    BMS_Y.Out9 = BMS_DW.Memory8_PreviousInput;



    /* Outport: '<Root>/Out10' incorporates:

     *  Memory: '<Root>/Memory10'

     */

    BMS_Y.Out10 = BMS_DW.Memory10_PreviousInput;

  }



  /* Integrator: '<S32>/Integrator' */

  BMS_B.Integrator = BMS_X.Integrator_CSTATE;



  /* Integrator: '<S37>/Integrator' */

  BMS_B.Integrator_d = BMS_X.Integrator_CSTATE_k;



  /* Integrator: '<S42>/Integrator' */

  BMS_B.Integrator_g = BMS_X.Integrator_CSTATE_g;



  /* Integrator: '<S47>/Integrator' */

  BMS_B.Integrator_gh = BMS_X.Integrator_CSTATE_f;



  /* Integrator: '<S52>/Integrator' */

  BMS_B.Integrator_e = BMS_X.Integrator_CSTATE_h;



  /* Integrator: '<S57>/Integrator' */

  BMS_B.Integrator_j = BMS_X.Integrator_CSTATE_a;



  /* Integrator: '<S62>/Integrator' */

  BMS_B.Integrator_p = BMS_X.Integrator_CSTATE_n;



  /* Integrator: '<S67>/Integrator' */

  BMS_B.Integrator_h = BMS_X.Integrator_CSTATE_b;



  /* MinMax: '<S1>/MinMax' incorporates:

   *  MATLAB Function: '<S1>/mean'

   *  MATLAB Function: '<S2>/median'

   *  SignalConversion generated from: '<S15>/ SFunction '

   *  SignalConversion generated from: '<S6>/ SFunction '

   */

  tmpForInput_tmp[0] = BMS_B.Integrator;

  tmpForInput_tmp[1] = BMS_B.Integrator_d;

  tmpForInput_tmp[2] = BMS_B.Integrator_g;

  tmpForInput_tmp[3] = BMS_B.Integrator_gh;

  tmpForInput_tmp[4] = BMS_B.Integrator_e;

  tmpForInput_tmp[5] = BMS_B.Integrator_j;

  tmpForInput_tmp[6] = BMS_B.Integrator_p;

  tmpForInput_tmp[7] = BMS_B.Integrator_h;

  rtb_Add1_c = BMS_B.Integrator;

  for (sigIdx = 0; sigIdx < 7; sigIdx++) {

    rtb_Add1_c = fmin(rtb_Add1_c, tmpForInput_tmp[sigIdx + 1]);

  }



  /* RelationalOperator: '<S4>/Compare' incorporates:

   *  Constant: '<S4>/Constant'

   *  MinMax: '<S1>/MinMax'

   */

  BMS_B.Compare = (rtb_Add1_c <= BMS_P.CompareToConstant_const);



  /* Stop: '<S1>/Stop Simulation' */

  if (rtmIsMajorTimeStep(BMS_M) && BMS_B.Compare) {

    rtmSetStopRequested(BMS_M, 1);

  }



  /* End of Stop: '<S1>/Stop Simulation' */



  /* MATLAB Function: '<S2>/median' */

  sigIdx = 0;

  do {

    exitg1 = 0;

    if (sigIdx < 8) {

      if (rtIsNaN(tmpForInput_tmp[sigIdx])) {

        rtb_Add1_c = (rtNaN);

        exitg1 = 1;

      } else {

        sigIdx++;

      }

    } else {

      memcpy(&v[0], &tmpForInput_tmp[0], sizeof(real_T) << 3U);

      BMS_quickselect(v, 5, 1, 8, &rtb_Add1_c, &ifirst, &sigIdx);

      if (4 < ifirst) {

        BMS_quickselect(v, 4, 1, sigIdx - 1, &rtb_Add1_o, &ifirst, &unusedU2);

        if (rtIsInf(rtb_Add1_c) || rtIsInf(rtb_Add1_o)) {

          rtb_Add1_c = (rtb_Add1_c + rtb_Add1_o) / 2.0;

        } else {

          rtb_Add1_c += (rtb_Add1_o - rtb_Add1_c) / 2.0;

        }

      }



      exitg1 = 1;

    }

  } while (exitg1 == 0);



  /* Sum: '<S7>/Add1' incorporates:

   *  MATLAB Function: '<S2>/median'

   */

  rtb_Add1_o = BMS_B.Integrator_d - rtb_Add1_c;



  /* Relay: '<S7>/Relay' incorporates:

   *  Relay: '<S7>/Relay1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode = ((rtb_Add1_o >= BMS_P.Relay_OnVal) || ((!(rtb_Add1_o <=

      BMS_P.Relay_OffVal)) && BMS_DW.Relay_Mode));

    BMS_DW.Relay1_Mode = ((rtb_Add1_o >= BMS_P.Relay1_OnVal) || ((!(rtb_Add1_o <=

      BMS_P.Relay1_OffVal)) && BMS_DW.Relay1_Mode));

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S7>/Relay' */

    if (BMS_DW.Relay_Mode) {

      rtb_Add1_o = BMS_P.Relay_YOn;

    } else {

      rtb_Add1_o = BMS_P.Relay_YOff;

    }



    /* Relay: '<S7>/Relay1' */

    if (BMS_DW.Relay1_Mode) {

      rtb_Add7 = BMS_P.Relay1_YOn;

    } else {

      rtb_Add7 = BMS_P.Relay1_YOff;

    }



    /* Sum: '<S7>/Add2' */

    BMS_B.Add2 = rtb_Add1_o + rtb_Add7;

  }



  /* Sum: '<S8>/Add1' incorporates:

   *  MATLAB Function: '<S2>/median'

   */

  rtb_Add1_o = BMS_B.Integrator_g - rtb_Add1_c;



  /* Relay: '<S8>/Relay' incorporates:

   *  Relay: '<S8>/Relay1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode_a = ((rtb_Add1_o >= BMS_P.Relay_OnVal_c) || ((!(rtb_Add1_o

      <= BMS_P.Relay_OffVal_g)) && BMS_DW.Relay_Mode_a));

    BMS_DW.Relay1_Mode_j = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_g) ||

      ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_d)) && BMS_DW.Relay1_Mode_j));

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S8>/Relay' */

    if (BMS_DW.Relay_Mode_a) {

      rtb_Add1_o = BMS_P.Relay_YOn_h;

    } else {

      rtb_Add1_o = BMS_P.Relay_YOff_j;

    }



    /* Relay: '<S8>/Relay1' */

    if (BMS_DW.Relay1_Mode_j) {

      rtb_Add7 = BMS_P.Relay1_YOn_i;

    } else {

      rtb_Add7 = BMS_P.Relay1_YOff_a;

    }



    /* Sum: '<S8>/Add2' */

    BMS_B.Add2_l = rtb_Add1_o + rtb_Add7;

  }



  /* Sum: '<S9>/Add1' incorporates:

   *  MATLAB Function: '<S2>/median'

   */

  rtb_Add1_o = BMS_B.Integrator_gh - rtb_Add1_c;



  /* Relay: '<S9>/Relay' incorporates:

   *  Relay: '<S9>/Relay1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode_m = ((rtb_Add1_o >= BMS_P.Relay_OnVal_p) || ((!(rtb_Add1_o

      <= BMS_P.Relay_OffVal_n)) && BMS_DW.Relay_Mode_m));

    BMS_DW.Relay1_Mode_e = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_l) ||

      ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_l)) && BMS_DW.Relay1_Mode_e));

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S9>/Relay' */

    if (BMS_DW.Relay_Mode_m) {

      rtb_Add1_o = BMS_P.Relay_YOn_k;

    } else {

      rtb_Add1_o = BMS_P.Relay_YOff_b;

    }



    /* Relay: '<S9>/Relay1' */

    if (BMS_DW.Relay1_Mode_e) {

      rtb_Add7 = BMS_P.Relay1_YOn_ij;

    } else {

      rtb_Add7 = BMS_P.Relay1_YOff_i;

    }



    /* Sum: '<S9>/Add2' */

    BMS_B.Add2_c = rtb_Add1_o + rtb_Add7;

  }



  /* Sum: '<S10>/Add1' incorporates:

   *  MATLAB Function: '<S2>/median'

   */

  rtb_Add1_o = BMS_B.Integrator_e - rtb_Add1_c;



  /* Relay: '<S10>/Relay' incorporates:

   *  Relay: '<S10>/Relay1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode_k = ((rtb_Add1_o >= BMS_P.Relay_OnVal_a) || ((!(rtb_Add1_o

      <= BMS_P.Relay_OffVal_m)) && BMS_DW.Relay_Mode_k));

    BMS_DW.Relay1_Mode_n = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_a) ||

      ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_j)) && BMS_DW.Relay1_Mode_n));

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S10>/Relay' */

    if (BMS_DW.Relay_Mode_k) {

      rtb_Add1_o = BMS_P.Relay_YOn_f;

    } else {

      rtb_Add1_o = BMS_P.Relay_YOff_jk;

    }



    /* Relay: '<S10>/Relay1' */

    if (BMS_DW.Relay1_Mode_n) {

      rtb_Add7 = BMS_P.Relay1_YOn_io;

    } else {

      rtb_Add7 = BMS_P.Relay1_YOff_ie;

    }



    /* Sum: '<S10>/Add2' */

    BMS_B.Add2_c2 = rtb_Add1_o + rtb_Add7;

  }



  /* Sum: '<S11>/Add1' incorporates:

   *  MATLAB Function: '<S2>/median'

   */

  rtb_Add1_o = BMS_B.Integrator_j - rtb_Add1_c;



  /* Relay: '<S11>/Relay' incorporates:

   *  Relay: '<S11>/Relay1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode_p = ((rtb_Add1_o >= BMS_P.Relay_OnVal_i) || ((!(rtb_Add1_o

      <= BMS_P.Relay_OffVal_o)) && BMS_DW.Relay_Mode_p));

    BMS_DW.Relay1_Mode_jl = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_i) ||

      ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_p)) && BMS_DW.Relay1_Mode_jl));

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S11>/Relay' */

    if (BMS_DW.Relay_Mode_p) {

      rtb_Add1_o = BMS_P.Relay_YOn_o;

    } else {

      rtb_Add1_o = BMS_P.Relay_YOff_c;

    }



    /* Relay: '<S11>/Relay1' */

    if (BMS_DW.Relay1_Mode_jl) {

      rtb_Add7 = BMS_P.Relay1_YOn_o;

    } else {

      rtb_Add7 = BMS_P.Relay1_YOff_a0;

    }



    /* Sum: '<S11>/Add2' */

    BMS_B.Add2_m = rtb_Add1_o + rtb_Add7;

  }



  /* Sum: '<S12>/Add1' incorporates:

   *  MATLAB Function: '<S2>/median'

   */

  rtb_Add1_o = BMS_B.Integrator - rtb_Add1_c;



  /* Relay: '<S12>/Relay' incorporates:

   *  Relay: '<S12>/Relay1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode_ax = ((rtb_Add1_o >= BMS_P.Relay_OnVal_n) ||

      ((!(rtb_Add1_o <= BMS_P.Relay_OffVal_nr)) && BMS_DW.Relay_Mode_ax));

    BMS_DW.Relay1_Mode_a = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_h) ||

      ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_m)) && BMS_DW.Relay1_Mode_a));

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S12>/Relay' */

    if (BMS_DW.Relay_Mode_ax) {

      rtb_Add1_o = BMS_P.Relay_YOn_j;

    } else {

      rtb_Add1_o = BMS_P.Relay_YOff_i;

    }



    /* Relay: '<S12>/Relay1' */

    if (BMS_DW.Relay1_Mode_a) {

      rtb_Add7 = BMS_P.Relay1_YOn_i4;

    } else {

      rtb_Add7 = BMS_P.Relay1_YOff_e;

    }



    /* Sum: '<S12>/Add2' */

    BMS_B.Add2_a = rtb_Add1_o + rtb_Add7;

  }



  /* Sum: '<S13>/Add1' incorporates:

   *  MATLAB Function: '<S2>/median'

   */

  rtb_Add1_o = BMS_B.Integrator_p - rtb_Add1_c;



  /* Relay: '<S13>/Relay' incorporates:

   *  Relay: '<S13>/Relay1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode_ai = ((rtb_Add1_o >= BMS_P.Relay_OnVal_g) ||

      ((!(rtb_Add1_o <= BMS_P.Relay_OffVal_od)) && BMS_DW.Relay_Mode_ai));

    BMS_DW.Relay1_Mode_n0 = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_p) ||

      ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_e)) && BMS_DW.Relay1_Mode_n0));

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S13>/Relay' */

    if (BMS_DW.Relay_Mode_ai) {

      rtb_Add1_o = BMS_P.Relay_YOn_i;

    } else {

      rtb_Add1_o = BMS_P.Relay_YOff_a;

    }



    /* Relay: '<S13>/Relay1' */

    if (BMS_DW.Relay1_Mode_n0) {

      rtb_Add7 = BMS_P.Relay1_YOn_m;

    } else {

      rtb_Add7 = BMS_P.Relay1_YOff_h;

    }



    /* Sum: '<S13>/Add2' */

    BMS_B.Add2_j = rtb_Add1_o + rtb_Add7;

  }



  /* Sum: '<S14>/Add1' incorporates:

   *  MATLAB Function: '<S2>/median'

   */

  rtb_Add1_c = BMS_B.Integrator_h - rtb_Add1_c;



  /* Relay: '<S14>/Relay' incorporates:

   *  Relay: '<S14>/Relay1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode_i = ((rtb_Add1_c >= BMS_P.Relay_OnVal_l) || ((!(rtb_Add1_c

      <= BMS_P.Relay_OffVal_d)) && BMS_DW.Relay_Mode_i));

    BMS_DW.Relay1_Mode_f = ((rtb_Add1_c >= BMS_P.Relay1_OnVal_f) ||

      ((!(rtb_Add1_c <= BMS_P.Relay1_OffVal_dk)) && BMS_DW.Relay1_Mode_f));

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S14>/Relay' */

    if (BMS_DW.Relay_Mode_i) {

      rtb_Add1_o = BMS_P.Relay_YOn_kk;

    } else {

      rtb_Add1_o = BMS_P.Relay_YOff_e;

    }



    /* Relay: '<S14>/Relay1' */

    if (BMS_DW.Relay1_Mode_f) {

      rtb_Add7 = BMS_P.Relay1_YOn_a;

    } else {

      rtb_Add7 = BMS_P.Relay1_YOff_l;

    }



    /* Sum: '<S14>/Add2' */

    BMS_B.Add2_h = rtb_Add1_o + rtb_Add7;

  }



  /* MinMax: '<S3>/MinMax1' incorporates:

   *  Inport: '<Root>/U1'

   *  Inport: '<Root>/U2'

   *  Inport: '<Root>/U3'

   *  Inport: '<Root>/U4'

   *  Inport: '<Root>/U5'

   *  Inport: '<Root>/U6'

   *  Inport: '<Root>/U7'

   *  Inport: '<Root>/U8'

   */

  v[0] = BMS_U.U1;

  v[1] = BMS_U.U2;

  v[2] = BMS_U.U3;

  v[3] = BMS_U.U4;

  v[4] = BMS_U.U5;

  v[5] = BMS_U.U6;

  v[6] = BMS_U.U7;

  v[7] = BMS_U.U8;

  rtb_Add1_c = BMS_U.U1;

  for (sigIdx = 0; sigIdx < 7; sigIdx++) {

    rtb_Add1_c = fmax(rtb_Add1_c, v[sigIdx + 1]);

  }



  /* Relay: '<S3>/Relay' incorporates:

   *  MinMax: '<S3>/MinMax1'

   */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay_Mode_m5 = ((rtb_Add1_c >= BMS_P.Relay_OnVal_k) ||

      ((!(rtb_Add1_c <= BMS_P.Relay_OffVal_gv)) && BMS_DW.Relay_Mode_m5));

  }



  if (BMS_DW.Relay_Mode_m5) {

    BMS_B.Relay = BMS_P.Relay_YOn_l;

  } else {

    BMS_B.Relay = BMS_P.Relay_YOff_g;

  }



  /* End of Relay: '<S3>/Relay' */

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Bias: '<S3>/Bias' */

    rtb_Bias = BMS_B.Relay + BMS_P.Bias_Bias;



    /* Delay: '<S3>/Delay' */

    BMS_B.Delay = BMS_DW.Delay_DSTATE[0];

  }



  /* Product: '<S3>/Product' incorporates:

   *  MinMax: '<S3>/MinMax1'

   */

  rtb_Add1_o = BMS_B.Delay * rtb_Add1_c;



  /* Relay: '<S3>/Relay1' */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay1_Mode_i = ((rtb_Add1_o >= BMS_P.Relay1_OnVal_c) ||

      ((!(rtb_Add1_o <= BMS_P.Relay1_OffVal_ed)) && BMS_DW.Relay1_Mode_i));

  }



  if (BMS_DW.Relay1_Mode_i) {

    BMS_B.Relay1 = BMS_P.Relay1_YOn_mm;

  } else {

    BMS_B.Relay1 = BMS_P.Relay1_YOff_o;

  }



  /* End of Relay: '<S3>/Relay1' */

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Bias: '<S3>/Bias1' */

    rtb_Bias1 = BMS_B.Relay1 + BMS_P.Bias1_Bias;



    /* Delay: '<S3>/Delay1' */

    BMS_B.Delay1 = BMS_DW.Delay1_DSTATE[0];

  }



  /* Product: '<S3>/Product1' incorporates:

   *  MinMax: '<S3>/MinMax1'

   */

  rtb_Add1_o = BMS_B.Delay1 * rtb_Add1_c;



  /* Relay: '<S3>/Relay2' */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay2_Mode = ((rtb_Add1_o >= BMS_P.Relay2_OnVal) || ((!(rtb_Add1_o <=

      BMS_P.Relay2_OffVal)) && BMS_DW.Relay2_Mode));

  }



  if (BMS_DW.Relay2_Mode) {

    BMS_B.Relay2 = BMS_P.Relay2_YOn;

  } else {

    BMS_B.Relay2 = BMS_P.Relay2_YOff;

  }



  /* End of Relay: '<S3>/Relay2' */

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Bias: '<S3>/Bias2' */

    rtb_Bias2 = BMS_B.Relay2 + BMS_P.Bias2_Bias;



    /* Delay: '<S3>/Delay2' */

    BMS_B.Delay2 = BMS_DW.Delay2_DSTATE[0];

  }



  /* Product: '<S3>/Product2' incorporates:

   *  MinMax: '<S3>/MinMax1'

   */

  rtb_Add1_o = BMS_B.Delay2 * rtb_Add1_c;



  /* Relay: '<S3>/Relay3' */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay3_Mode = ((rtb_Add1_o >= BMS_P.Relay3_OnVal) || ((!(rtb_Add1_o <=

      BMS_P.Relay3_OffVal)) && BMS_DW.Relay3_Mode));

  }



  if (BMS_DW.Relay3_Mode) {

    BMS_B.Relay3 = BMS_P.Relay3_YOn;

  } else {

    BMS_B.Relay3 = BMS_P.Relay3_YOff;

  }



  /* End of Relay: '<S3>/Relay3' */

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Delay: '<S3>/Delay3' */

    BMS_B.Delay3 = BMS_DW.Delay3_DSTATE[0];



    /* Product: '<S3>/Divide3' incorporates:

     *  Bias: '<S3>/Bias3'

     *  Constant: '<S3>/Constant'

     *  Product: '<S3>/Divide'

     *  Product: '<S3>/Divide1'

     *  Product: '<S3>/Divide2'

     */

    rtb_Divide3 = BMS_P.Constant_Value / rtb_Bias / rtb_Bias1 / rtb_Bias2 /

      (BMS_B.Relay3 + BMS_P.Bias3_Bias);

  }



  /* Product: '<S3>/Product3' incorporates:

   *  MinMax: '<S3>/MinMax1'

   */

  rtb_Bias = BMS_B.Delay3 * rtb_Add1_c;



  /* Relay: '<S3>/Relay6' */

  if (rtmIsMajorTimeStep(BMS_M)) {

    BMS_DW.Relay6_Mode = ((rtb_Bias >= BMS_P.Relay6_OnVal) || ((!(rtb_Bias <=

      BMS_P.Relay6_OffVal)) && BMS_DW.Relay6_Mode));

  }



  /* Product: '<S33>/Divide' incorporates:

   *  Constant: '<S33>/Cnom'

   *  Integrator: '<S33>/Integrator6'

   *  Math: '<S33>/Math Function'

   *

   * About '<S33>/Math Function':

   *  Operator: exp

   */

  BMS_B.Divide = BMS_P.Cnom_Value * exp(BMS_X.Integrator6_CSTATE);



  /* Product: '<S38>/Divide' incorporates:

   *  Constant: '<S38>/Cnom'

   *  Integrator: '<S38>/Integrator6'

   *  Math: '<S38>/Math Function'

   *

   * About '<S38>/Math Function':

   *  Operator: exp

   */

  BMS_B.Divide_l = BMS_P.Cnom_Value_d * exp(BMS_X.Integrator6_CSTATE_h);



  /* Product: '<S43>/Divide' incorporates:

   *  Constant: '<S43>/Cnom'

   *  Integrator: '<S43>/Integrator6'

   *  Math: '<S43>/Math Function'

   *

   * About '<S43>/Math Function':

   *  Operator: exp

   */

  BMS_B.Divide_l4 = BMS_P.Cnom_Value_f * exp(BMS_X.Integrator6_CSTATE_d);



  /* Product: '<S48>/Divide' incorporates:

   *  Constant: '<S48>/Cnom'

   *  Integrator: '<S48>/Integrator6'

   *  Math: '<S48>/Math Function'

   *

   * About '<S48>/Math Function':

   *  Operator: exp

   */

  BMS_B.Divide_m = BMS_P.Cnom_Value_m * exp(BMS_X.Integrator6_CSTATE_g);



  /* Product: '<S53>/Divide' incorporates:

   *  Constant: '<S53>/Cnom'

   *  Integrator: '<S53>/Integrator6'

   *  Math: '<S53>/Math Function'

   *

   * About '<S53>/Math Function':

   *  Operator: exp

   */

  BMS_B.Divide_l2 = BMS_P.Cnom_Value_k * exp(BMS_X.Integrator6_CSTATE_a);



  /* Product: '<S58>/Divide' incorporates:

   *  Constant: '<S58>/Cnom'

   *  Integrator: '<S58>/Integrator6'

   *  Math: '<S58>/Math Function'

   *

   * About '<S58>/Math Function':

   *  Operator: exp

   */

  BMS_B.Divide_a = BMS_P.Cnom_Value_i * exp(BMS_X.Integrator6_CSTATE_f);



  /* Product: '<S63>/Divide' incorporates:

   *  Constant: '<S63>/Cnom'

   *  Integrator: '<S63>/Integrator6'

   *  Math: '<S63>/Math Function'

   *

   * About '<S63>/Math Function':

   *  Operator: exp

   */

  BMS_B.Divide_n = BMS_P.Cnom_Value_e * exp(BMS_X.Integrator6_CSTATE_hq);



  /* Product: '<S68>/Divide' incorporates:

   *  Constant: '<S68>/Cnom'

   *  Integrator: '<S68>/Integrator6'

   *  Math: '<S68>/Math Function'

   *

   * About '<S68>/Math Function':

   *  Operator: exp

   */

  BMS_B.Divide_mm = BMS_P.Cnom_Value_mh * exp(BMS_X.Integrator6_CSTATE_b);

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Relay: '<S3>/Relay6' */

    if (BMS_DW.Relay6_Mode) {

      rtb_Add1_o = BMS_P.Relay6_YOn;

    } else {

      rtb_Add1_o = BMS_P.Relay6_YOff;

    }



    /* Product: '<S3>/Product5' */

    BMS_B.Product5 = rtb_Divide3 * rtb_Add1_o;

  }



  /* Product: '<S33>/Divide1' incorporates:

   *  Constant: '<S33>/Rnom'

   *  Integrator: '<S33>/Integrator3'

   *  Math: '<S33>/Math Function1'

   *

   * About '<S33>/Math Function1':

   *  Operator: exp

   */

  BMS_B.Divide1 = BMS_P.Rnom_Value * exp(BMS_X.Integrator3_CSTATE);



  /* Product: '<S38>/Divide1' incorporates:

   *  Constant: '<S38>/Rnom'

   *  Integrator: '<S38>/Integrator3'

   *  Math: '<S38>/Math Function1'

   *

   * About '<S38>/Math Function1':

   *  Operator: exp

   */

  BMS_B.Divide1_n = BMS_P.Rnom_Value_a * exp(BMS_X.Integrator3_CSTATE_i);



  /* Product: '<S43>/Divide1' incorporates:

   *  Constant: '<S43>/Rnom'

   *  Integrator: '<S43>/Integrator3'

   *  Math: '<S43>/Math Function1'

   *

   * About '<S43>/Math Function1':

   *  Operator: exp

   */

  BMS_B.Divide1_j = BMS_P.Rnom_Value_m * exp(BMS_X.Integrator3_CSTATE_h);



  /* Product: '<S48>/Divide1' incorporates:

   *  Constant: '<S48>/Rnom'

   *  Integrator: '<S48>/Integrator3'

   *  Math: '<S48>/Math Function1'

   *

   * About '<S48>/Math Function1':

   *  Operator: exp

   */

  BMS_B.Divide1_p = BMS_P.Rnom_Value_e * exp(BMS_X.Integrator3_CSTATE_hr);



  /* Product: '<S53>/Divide1' incorporates:

   *  Constant: '<S53>/Rnom'

   *  Integrator: '<S53>/Integrator3'

   *  Math: '<S53>/Math Function1'

   *

   * About '<S53>/Math Function1':

   *  Operator: exp

   */

  BMS_B.Divide1_jl = BMS_P.Rnom_Value_l * exp(BMS_X.Integrator3_CSTATE_d);



  /* Product: '<S58>/Divide1' incorporates:

   *  Constant: '<S58>/Rnom'

   *  Integrator: '<S58>/Integrator3'

   *  Math: '<S58>/Math Function1'

   *

   * About '<S58>/Math Function1':

   *  Operator: exp

   */

  BMS_B.Divide1_nb = BMS_P.Rnom_Value_d * exp(BMS_X.Integrator3_CSTATE_f);



  /* Product: '<S63>/Divide1' incorporates:

   *  Constant: '<S63>/Rnom'

   *  Integrator: '<S63>/Integrator3'

   *  Math: '<S63>/Math Function1'

   *

   * About '<S63>/Math Function1':

   *  Operator: exp

   */

  BMS_B.Divide1_c = BMS_P.Rnom_Value_p * exp(BMS_X.Integrator3_CSTATE_dt);



  /* Product: '<S68>/Divide1' incorporates:

   *  Constant: '<S68>/Rnom'

   *  Integrator: '<S68>/Integrator3'

   *  Math: '<S68>/Math Function1'

   *

   * About '<S68>/Math Function1':

   *  Operator: exp

   */

  BMS_B.Divide1_i = BMS_P.Rnom_Value_i * exp(BMS_X.Integrator3_CSTATE_o);

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Gain: '<S5>/Gain4' */

    BMS_B.Gain4 = BMS_P.Gain4_Gain * BMS_B.Add2_c2;

  }



  /* MATLAB Function: '<S5>/dead_band4' incorporates:

   *  Inport: '<Root>/I'

   */

  BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band4);



  /* Sum: '<S5>/Add1' */

  rtb_Divide3 = BMS_B.Gain4 + BMS_B.sf_dead_band4.y;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Gain: '<S5>/Gain5' */

    BMS_B.Gain5 = BMS_P.Gain5_Gain * BMS_B.Add2_m;

  }



  /* MATLAB Function: '<S5>/dead_band5' incorporates:

   *  Inport: '<Root>/I'

   */

  BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band5);



  /* Sum: '<S5>/Add2' */

  rtb_Bias = BMS_B.Gain5 + BMS_B.sf_dead_band5.y;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Gain: '<S5>/Gain6' */

    BMS_B.Gain6 = BMS_P.Gain6_Gain * BMS_B.Add2_j;

  }



  /* MATLAB Function: '<S5>/dead_band6' incorporates:

   *  Inport: '<Root>/I'

   */

  BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band6);



  /* Sum: '<S5>/Add3' */

  rtb_Bias1 = BMS_B.Gain6 + BMS_B.sf_dead_band6.y;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Gain: '<S5>/Gain7' */

    BMS_B.Gain7 = BMS_P.Gain7_Gain * BMS_B.Add2_h;

  }



  /* MATLAB Function: '<S5>/dead_band7' incorporates:

   *  Inport: '<Root>/I'

   */

  BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band7);



  /* Sum: '<S5>/Add4' */

  rtb_Bias2 = BMS_B.Gain7 + BMS_B.sf_dead_band7.y;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Gain: '<S5>/Gain3' */

    BMS_B.Gain3 = BMS_P.Gain3_Gain * BMS_B.Add2_c;

  }



  /* MATLAB Function: '<S5>/dead_band3' incorporates:

   *  Inport: '<Root>/I'

   */

  BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band3);



  /* Sum: '<S5>/Add5' */

  rtb_Add1_c = BMS_B.Gain3 + BMS_B.sf_dead_band3.y;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Gain: '<S5>/Gain2' */

    BMS_B.Gain2 = BMS_P.Gain2_Gain * BMS_B.Add2_l;

  }



  /* MATLAB Function: '<S5>/dead_band2' incorporates:

   *  Inport: '<Root>/I'

   */

  BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band2);



  /* Sum: '<S5>/Add6' */

  rtb_Add1_o = BMS_B.Gain2 + BMS_B.sf_dead_band2.y;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Gain: '<S5>/Gain1' */

    BMS_B.Gain1 = BMS_P.Gain1_Gain * BMS_B.Add2;

  }



  /* MATLAB Function: '<S5>/dead_band1' incorporates:

   *  Inport: '<Root>/I'

   */

  BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band1);



  /* Sum: '<S5>/Add7' */

  rtb_Add7 = BMS_B.Gain1 + BMS_B.sf_dead_band1.y;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Gain: '<S5>/Gain' */

    BMS_B.Gain = BMS_P.Gain_Gain * BMS_B.Add2_a;

  }



  /* MATLAB Function: '<S5>/dead_band' incorporates:

   *  Inport: '<Root>/I'

   */

  BMS_dead_band(BMS_U.I, &BMS_B.sf_dead_band);



  /* Sum: '<S5>/Add8' */

  rtb_Add8 = BMS_B.Gain + BMS_B.sf_dead_band.y;



  /* Sum: '<S32>/Add2' incorporates:

   *  Inport: '<Root>/T'

   *  Inport: '<Root>/U1'

   *  Lookup_n-D: '<S32>/2-D Lookup Table: OCV - SoC'

   *  Product: '<S32>/Product1'

   *  Sum: '<S32>/Add1'

   */

  rtb_Sqrt = BMS_U.U1 - (BMS_B.Divide1 * rtb_Add8 + look2_binlxpw

    (BMS_B.Integrator, BMS_U.T, BMS_P.uDLookupTableOCVSoC_bp01Data,

     BMS_P.uDLookupTableOCVSoC_bp02Data, BMS_P.uDLookupTableOCVSoC_tableData,

     BMS_P.uDLookupTableOCVSoC_maxIndex, 21U));



  /* Fcn: '<S34>/abs' incorporates:

   *  Gain: '<S34>/Gain2'

   */

  BMS_B.abs_p = fabs(BMS_P.Gain2_Gain_g * rtb_Add8);



  /* Lookup_n-D: '<S34>/1-D Lookup Table' incorporates:

   *  Gain: '<S34>/Gain3'

   *  Sum: '<S34>/Add3'

   *  TransferFcn: '<S34>/Transfer Fcn1'

   */

  BMS_B.uDLookupTable = look1_binlxpw((((BMS_P.TransferFcn1_C[0] *

    BMS_X.TransferFcn1_CSTATE[0] + BMS_P.TransferFcn1_C[1] *

    BMS_X.TransferFcn1_CSTATE[1]) + BMS_P.TransferFcn1_C[2] *

    BMS_X.TransferFcn1_CSTATE[2]) + BMS_B.abs_p) * BMS_P.Gain3_Gain_l,

    BMS_P.uDLookupTable_bp01Data, BMS_P.uDLookupTable_tableData, 6U);



  /* DeadZone: '<S32>/Dead Zone' */

  if (rtb_Sqrt > BMS_P.DeadZone_End) {

    rtb_TransferFcn1 = rtb_Sqrt - BMS_P.DeadZone_End;

  } else if (rtb_Sqrt >= BMS_P.DeadZone_Start) {

    rtb_TransferFcn1 = 0.0;

  } else {

    rtb_TransferFcn1 = rtb_Sqrt - BMS_P.DeadZone_Start;

  }



  /* End of DeadZone: '<S32>/Dead Zone' */



  /* Product: '<S32>/Product' incorporates:

   *  Gain: '<S32>/Gain4'

   */

  rtb_Product_o2 = BMS_P.SOCestimator_gainU * BMS_B.uDLookupTable *

    rtb_TransferFcn1;



  /* Gain: '<S32>/Gain' incorporates:

   *  Product: '<S32>/Divide'

   *  Sum: '<S32>/Sum1'

   */

  BMS_B.Gain_p = (1.0 / BMS_B.Divide * rtb_Add8 + rtb_Product_o2) *

    BMS_P.Gain_Gain_e;



  /* TransferFcn: '<S35>/Transfer Fcn4' */

  BMS_B.TransferFcn4 = 0.0;

  BMS_B.TransferFcn4 += BMS_P.TransferFcn4_C[0] * BMS_X.TransferFcn4_CSTATE[0];

  BMS_B.TransferFcn4 += BMS_P.TransferFcn4_C[1] * BMS_X.TransferFcn4_CSTATE[1];

  BMS_B.TransferFcn4 += BMS_P.TransferFcn4_C[2] * BMS_X.TransferFcn4_CSTATE[2];



  /* TransferFcn: '<S35>/Transfer Fcn1' */

  rtb_TransferFcn1 = BMS_P.TransferFcn1_C_j * BMS_X.TransferFcn1_CSTATE_j +

    BMS_P.TransferFcn1_D * BMS_B.TransferFcn4;



  /* Sqrt: '<S35>/Sqrt'

   *

   * About '<S35>/Sqrt':

   *  Operator: signedSqrt

   */

  if (rtb_TransferFcn1 < 0.0) {

    rtb_TransferFcn1 = -sqrt(fabs(rtb_TransferFcn1));

  } else {

    rtb_TransferFcn1 = sqrt(rtb_TransferFcn1);

  }



  /* End of Sqrt: '<S35>/Sqrt' */



  /* Gain: '<S35>/Gain' */

  BMS_B.Gain_d = BMS_P.Gain_Gain_f * rtb_TransferFcn1;



  /* Product: '<S35>/Product' incorporates:

   *  Gain: '<S35>/Gain1'

   */

  BMS_B.Product = BMS_P.Gain1_Gain_b * rtb_Add8 * rtb_Sqrt;



  /* Integrator: '<S36>/Integrator' */

  BMS_B.Integrator_i = BMS_X.Integrator_CSTATE_n5;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S36>/Gain3' */

  BMS_B.Gain3_a = BMS_P.Gain3_Gain_h * rtb_Product_o2;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S36>/Gain1' incorporates:

   *  Product: '<S36>/Product'

   */

  BMS_B.Gain1_i = BMS_B.Integrator_i * BMS_B.Gain3_a * BMS_P.Gain1_Gain_i;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S36>/Gain' */

  BMS_B.Gain_e = BMS_P.Gain_Gain_d * BMS_B.Gain1_i;



  /* Gain: '<S36>/Gain4' incorporates:

   *  Gain: '<S36>/Gain2'

   *  Gain: '<S36>/Gain5'

   *  Product: '<S36>/Product1'

   *  Sum: '<S36>/Sum'

   *  TransferFcn: '<S36>/Transfer Fcn1'

   */

  BMS_B.Gain4_h = (BMS_P.Gain2_Gain_gl * rtb_Add8 - ((BMS_P.TransferFcn1_C_f[0] *

    BMS_X.TransferFcn1_CSTATE_a[0] + BMS_P.TransferFcn1_C_f[1] *

    BMS_X.TransferFcn1_CSTATE_a[1]) + BMS_P.TransferFcn1_C_f[2] *

    BMS_X.TransferFcn1_CSTATE_a[2]) * BMS_B.Integrator_i * BMS_P.Gain5_Gain_d) *

    BMS_P.Gain4_Gain_h;



  /* Sum: '<S37>/Add2' incorporates:

   *  Inport: '<Root>/T'

   *  Inport: '<Root>/U2'

   *  Lookup_n-D: '<S37>/2-D Lookup Table'

   *  Product: '<S37>/Product1'

   *  Sum: '<S37>/Add1'

   */

  rtb_TransferFcn1 = BMS_U.U2 - (BMS_B.Divide1_n * rtb_Add7 + look2_binlxpw

    (BMS_B.Integrator_d, BMS_U.T, BMS_P.uDLookupTable_bp01Data_b,

     BMS_P.uDLookupTable_bp02Data, BMS_P.uDLookupTable_tableData_j,

     BMS_P.uDLookupTable_maxIndex, 21U));



  /* Fcn: '<S39>/abs' incorporates:

   *  Gain: '<S39>/Gain2'

   */

  BMS_B.abs_j = fabs(BMS_P.Gain2_Gain_b * rtb_Add7);



  /* Lookup_n-D: '<S39>/1-D Lookup Table' incorporates:

   *  Gain: '<S39>/Gain3'

   *  Sum: '<S39>/Add3'

   *  TransferFcn: '<S39>/Transfer Fcn1'

   */

  BMS_B.uDLookupTable_b = look1_binlxpw((((BMS_P.TransferFcn1_C_p[0] *

    BMS_X.TransferFcn1_CSTATE_l[0] + BMS_P.TransferFcn1_C_p[1] *

    BMS_X.TransferFcn1_CSTATE_l[1]) + BMS_P.TransferFcn1_C_p[2] *

    BMS_X.TransferFcn1_CSTATE_l[2]) + BMS_B.abs_j) * BMS_P.Gain3_Gain_o,

    BMS_P.uDLookupTable_bp01Data_n, BMS_P.uDLookupTable_tableData_g, 6U);



  /* DeadZone: '<S37>/Dead Zone' */

  if (rtb_TransferFcn1 > BMS_P.DeadZone_End_a) {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_a;

  } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_a) {

    rtb_Add8 = 0.0;

  } else {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_a;

  }



  /* End of DeadZone: '<S37>/Dead Zone' */



  /* Product: '<S37>/Product' incorporates:

   *  Gain: '<S37>/Gain4'

   */

  rtb_Product_o2 = BMS_P.SOCestimator_gainU_p * BMS_B.uDLookupTable_b * rtb_Add8;



  /* Gain: '<S37>/Gain' incorporates:

   *  Product: '<S37>/Divide'

   *  Sum: '<S37>/Sum1'

   */

  BMS_B.Gain_k = (1.0 / BMS_B.Divide_l * rtb_Add7 + rtb_Product_o2) *

    BMS_P.Gain_Gain_m;



  /* TransferFcn: '<S40>/Transfer Fcn4' */

  BMS_B.TransferFcn4_h = 0.0;

  BMS_B.TransferFcn4_h += BMS_P.TransferFcn4_C_l[0] *

    BMS_X.TransferFcn4_CSTATE_e[0];

  BMS_B.TransferFcn4_h += BMS_P.TransferFcn4_C_l[1] *

    BMS_X.TransferFcn4_CSTATE_e[1];

  BMS_B.TransferFcn4_h += BMS_P.TransferFcn4_C_l[2] *

    BMS_X.TransferFcn4_CSTATE_e[2];



  /* TransferFcn: '<S40>/Transfer Fcn1' */

  rtb_Sqrt = BMS_P.TransferFcn1_C_d * BMS_X.TransferFcn1_CSTATE_g +

    BMS_P.TransferFcn1_D_b * BMS_B.TransferFcn4_h;



  /* Sqrt: '<S40>/Sqrt'

   *

   * About '<S40>/Sqrt':

   *  Operator: signedSqrt

   */

  if (rtb_Sqrt < 0.0) {

    rtb_Sqrt = -sqrt(fabs(rtb_Sqrt));

  } else {

    rtb_Sqrt = sqrt(rtb_Sqrt);

  }



  /* End of Sqrt: '<S40>/Sqrt' */



  /* Gain: '<S40>/Gain' */

  BMS_B.Gain_c = BMS_P.Gain_Gain_h * rtb_Sqrt;



  /* Product: '<S40>/Product' incorporates:

   *  Gain: '<S40>/Gain1'

   */

  BMS_B.Product_c = BMS_P.Gain1_Gain_k * rtb_Add7 * rtb_TransferFcn1;



  /* Integrator: '<S41>/Integrator' */

  BMS_B.Integrator_dt = BMS_X.Integrator_CSTATE_nm;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S41>/Gain3' */

  BMS_B.Gain3_g = BMS_P.Gain3_Gain_n * rtb_Product_o2;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S41>/Gain1' incorporates:

   *  Product: '<S41>/Product'

   */

  BMS_B.Gain1_j = BMS_B.Integrator_dt * BMS_B.Gain3_g * BMS_P.Gain1_Gain_c;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S41>/Gain' */

  BMS_B.Gain_n = BMS_P.Gain_Gain_j * BMS_B.Gain1_j;



  /* Gain: '<S41>/Gain4' incorporates:

   *  Gain: '<S41>/Gain2'

   *  Gain: '<S41>/Gain5'

   *  Product: '<S41>/Product1'

   *  Sum: '<S41>/Sum'

   *  TransferFcn: '<S41>/Transfer Fcn1'

   */

  BMS_B.Gain4_k = (BMS_P.Gain2_Gain_h * rtb_Add7 - ((BMS_P.TransferFcn1_C_m[0] *

    BMS_X.TransferFcn1_CSTATE_b[0] + BMS_P.TransferFcn1_C_m[1] *

    BMS_X.TransferFcn1_CSTATE_b[1]) + BMS_P.TransferFcn1_C_m[2] *

    BMS_X.TransferFcn1_CSTATE_b[2]) * BMS_B.Integrator_dt * BMS_P.Gain5_Gain_f) *

    BMS_P.Gain4_Gain_c;



  /* Sum: '<S42>/Add2' incorporates:

   *  Inport: '<Root>/T'

   *  Inport: '<Root>/U3'

   *  Lookup_n-D: '<S42>/2-D Lookup Table'

   *  Product: '<S42>/Product1'

   *  Sum: '<S42>/Add1'

   */

  rtb_TransferFcn1 = BMS_U.U3 - (BMS_B.Divide1_j * rtb_Add1_o + look2_binlxpw

    (BMS_B.Integrator_g, BMS_U.T, BMS_P.uDLookupTable_bp01Data_j,

     BMS_P.uDLookupTable_bp02Data_g, BMS_P.uDLookupTable_tableData_k,

     BMS_P.uDLookupTable_maxIndex_n, 21U));



  /* Fcn: '<S44>/abs' incorporates:

   *  Gain: '<S44>/Gain2'

   */

  BMS_B.abs_e = fabs(BMS_P.Gain2_Gain_bv * rtb_Add1_o);



  /* Lookup_n-D: '<S44>/1-D Lookup Table' incorporates:

   *  Gain: '<S44>/Gain3'

   *  Sum: '<S44>/Add3'

   *  TransferFcn: '<S44>/Transfer Fcn1'

   */

  BMS_B.uDLookupTable_f = look1_binlxpw((((BMS_P.TransferFcn1_C_l[0] *

    BMS_X.TransferFcn1_CSTATE_c[0] + BMS_P.TransferFcn1_C_l[1] *

    BMS_X.TransferFcn1_CSTATE_c[1]) + BMS_P.TransferFcn1_C_l[2] *

    BMS_X.TransferFcn1_CSTATE_c[2]) + BMS_B.abs_e) * BMS_P.Gain3_Gain_j,

    BMS_P.uDLookupTable_bp01Data_d, BMS_P.uDLookupTable_tableData_g4, 6U);



  /* DeadZone: '<S42>/Dead Zone' */

  if (rtb_TransferFcn1 > BMS_P.DeadZone_End_i) {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_i;

  } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_m) {

    rtb_Add8 = 0.0;

  } else {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_m;

  }



  /* End of DeadZone: '<S42>/Dead Zone' */



  /* Product: '<S42>/Product' incorporates:

   *  Gain: '<S42>/Gain4'

   */

  rtb_Product_o2 = BMS_P.SOCestimator_gainU_h * BMS_B.uDLookupTable_f * rtb_Add8;



  /* Gain: '<S42>/Gain' incorporates:

   *  Product: '<S42>/Divide'

   *  Sum: '<S42>/Sum1'

   */

  BMS_B.Gain_db = (1.0 / BMS_B.Divide_l4 * rtb_Add1_o + rtb_Product_o2) *

    BMS_P.Gain_Gain_l;



  /* TransferFcn: '<S45>/Transfer Fcn4' */

  BMS_B.TransferFcn4_o = 0.0;

  BMS_B.TransferFcn4_o += BMS_P.TransferFcn4_C_c[0] *

    BMS_X.TransferFcn4_CSTATE_h[0];

  BMS_B.TransferFcn4_o += BMS_P.TransferFcn4_C_c[1] *

    BMS_X.TransferFcn4_CSTATE_h[1];

  BMS_B.TransferFcn4_o += BMS_P.TransferFcn4_C_c[2] *

    BMS_X.TransferFcn4_CSTATE_h[2];



  /* TransferFcn: '<S45>/Transfer Fcn1' */

  rtb_Sqrt = BMS_P.TransferFcn1_C_g * BMS_X.TransferFcn1_CSTATE_f +

    BMS_P.TransferFcn1_D_n * BMS_B.TransferFcn4_o;



  /* Sqrt: '<S45>/Sqrt'

   *

   * About '<S45>/Sqrt':

   *  Operator: signedSqrt

   */

  if (rtb_Sqrt < 0.0) {

    rtb_Sqrt = -sqrt(fabs(rtb_Sqrt));

  } else {

    rtb_Sqrt = sqrt(rtb_Sqrt);

  }



  /* End of Sqrt: '<S45>/Sqrt' */



  /* Gain: '<S45>/Gain' */

  BMS_B.Gain_h = BMS_P.Gain_Gain_fy * rtb_Sqrt;



  /* Product: '<S45>/Product' incorporates:

   *  Gain: '<S45>/Gain1'

   */

  BMS_B.Product_e = BMS_P.Gain1_Gain_l * rtb_Add1_o * rtb_TransferFcn1;



  /* Integrator: '<S46>/Integrator' */

  BMS_B.Integrator_k = BMS_X.Integrator_CSTATE_kc;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S46>/Gain3' */

  BMS_B.Gain3_n = BMS_P.Gain3_Gain_p * rtb_Product_o2;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S46>/Gain1' incorporates:

   *  Product: '<S46>/Product'

   */

  BMS_B.Gain1_h = BMS_B.Integrator_k * BMS_B.Gain3_n * BMS_P.Gain1_Gain_c3;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S46>/Gain' */

  BMS_B.Gain_f = BMS_P.Gain_Gain_jg * BMS_B.Gain1_h;



  /* Gain: '<S46>/Gain4' incorporates:

   *  Gain: '<S46>/Gain2'

   *  Gain: '<S46>/Gain5'

   *  Product: '<S46>/Product1'

   *  Sum: '<S46>/Sum'

   *  TransferFcn: '<S46>/Transfer Fcn1'

   */

  BMS_B.Gain4_i = (BMS_P.Gain2_Gain_by * rtb_Add1_o - ((BMS_P.TransferFcn1_C_h[0]

    * BMS_X.TransferFcn1_CSTATE_n[0] + BMS_P.TransferFcn1_C_h[1] *

    BMS_X.TransferFcn1_CSTATE_n[1]) + BMS_P.TransferFcn1_C_h[2] *

    BMS_X.TransferFcn1_CSTATE_n[2]) * BMS_B.Integrator_k * BMS_P.Gain5_Gain_h) *

    BMS_P.Gain4_Gain_n;



  /* Sum: '<S47>/Add2' incorporates:

   *  Inport: '<Root>/T'

   *  Inport: '<Root>/U4'

   *  Lookup_n-D: '<S47>/2-D Lookup Table'

   *  Product: '<S47>/Product1'

   *  Sum: '<S47>/Add1'

   */

  rtb_TransferFcn1 = BMS_U.U4 - (BMS_B.Divide1_p * rtb_Add1_c + look2_binlxpw

    (BMS_B.Integrator_gh, BMS_U.T, BMS_P.uDLookupTable_bp01Data_f,

     BMS_P.uDLookupTable_bp02Data_o, BMS_P.uDLookupTable_tableData_g5,

     BMS_P.uDLookupTable_maxIndex_l, 21U));



  /* Fcn: '<S49>/abs' incorporates:

   *  Gain: '<S49>/Gain2'

   */

  BMS_B.abs_d = fabs(BMS_P.Gain2_Gain_o * rtb_Add1_c);



  /* Lookup_n-D: '<S49>/1-D Lookup Table' incorporates:

   *  Gain: '<S49>/Gain3'

   *  Sum: '<S49>/Add3'

   *  TransferFcn: '<S49>/Transfer Fcn1'

   */

  BMS_B.uDLookupTable_h = look1_binlxpw((((BMS_P.TransferFcn1_C_dc[0] *

    BMS_X.TransferFcn1_CSTATE_am[0] + BMS_P.TransferFcn1_C_dc[1] *

    BMS_X.TransferFcn1_CSTATE_am[1]) + BMS_P.TransferFcn1_C_dc[2] *

    BMS_X.TransferFcn1_CSTATE_am[2]) + BMS_B.abs_d) * BMS_P.Gain3_Gain_lw,

    BMS_P.uDLookupTable_bp01Data_a, BMS_P.uDLookupTable_tableData_p, 6U);



  /* DeadZone: '<S47>/Dead Zone' */

  if (rtb_TransferFcn1 > BMS_P.DeadZone_End_k) {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_k;

  } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_l) {

    rtb_Add8 = 0.0;

  } else {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_l;

  }



  /* End of DeadZone: '<S47>/Dead Zone' */



  /* Product: '<S47>/Product' incorporates:

   *  Gain: '<S47>/Gain4'

   */

  rtb_Product_o2 = BMS_P.SOCestimator_gainU_k * BMS_B.uDLookupTable_h * rtb_Add8;



  /* Gain: '<S47>/Gain' incorporates:

   *  Product: '<S47>/Divide'

   *  Sum: '<S47>/Sum1'

   */

  BMS_B.Gain_pt = (1.0 / BMS_B.Divide_m * rtb_Add1_c + rtb_Product_o2) *

    BMS_P.Gain_Gain_en;



  /* TransferFcn: '<S50>/Transfer Fcn4' */

  BMS_B.TransferFcn4_d = 0.0;

  BMS_B.TransferFcn4_d += BMS_P.TransferFcn4_C_k[0] *

    BMS_X.TransferFcn4_CSTATE_m[0];

  BMS_B.TransferFcn4_d += BMS_P.TransferFcn4_C_k[1] *

    BMS_X.TransferFcn4_CSTATE_m[1];

  BMS_B.TransferFcn4_d += BMS_P.TransferFcn4_C_k[2] *

    BMS_X.TransferFcn4_CSTATE_m[2];



  /* TransferFcn: '<S50>/Transfer Fcn1' */

  rtb_Sqrt = BMS_P.TransferFcn1_C_e * BMS_X.TransferFcn1_CSTATE_c1 +

    BMS_P.TransferFcn1_D_bu * BMS_B.TransferFcn4_d;



  /* Sqrt: '<S50>/Sqrt'

   *

   * About '<S50>/Sqrt':

   *  Operator: signedSqrt

   */

  if (rtb_Sqrt < 0.0) {

    rtb_Sqrt = -sqrt(fabs(rtb_Sqrt));

  } else {

    rtb_Sqrt = sqrt(rtb_Sqrt);

  }



  /* End of Sqrt: '<S50>/Sqrt' */



  /* Gain: '<S50>/Gain' */

  BMS_B.Gain_b = BMS_P.Gain_Gain_g * rtb_Sqrt;



  /* Product: '<S50>/Product' incorporates:

   *  Gain: '<S50>/Gain1'

   */

  BMS_B.Product_b = BMS_P.Gain1_Gain_bs * rtb_Add1_c * rtb_TransferFcn1;



  /* Integrator: '<S51>/Integrator' */

  BMS_B.Integrator_o = BMS_X.Integrator_CSTATE_fh;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S51>/Gain3' */

  BMS_B.Gain3_c = BMS_P.Gain3_Gain_ny * rtb_Product_o2;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S51>/Gain1' incorporates:

   *  Product: '<S51>/Product'

   */

  BMS_B.Gain1_hl = BMS_B.Integrator_o * BMS_B.Gain3_c * BMS_P.Gain1_Gain_o;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S51>/Gain' */

  BMS_B.Gain_nj = BMS_P.Gain_Gain_enb * BMS_B.Gain1_hl;



  /* Gain: '<S51>/Gain4' incorporates:

   *  Gain: '<S51>/Gain2'

   *  Gain: '<S51>/Gain5'

   *  Product: '<S51>/Product1'

   *  Sum: '<S51>/Sum'

   *  TransferFcn: '<S51>/Transfer Fcn1'

   */

  BMS_B.Gain4_l = (BMS_P.Gain2_Gain_j * rtb_Add1_c - ((BMS_P.TransferFcn1_C_n[0]

    * BMS_X.TransferFcn1_CSTATE_ff[0] + BMS_P.TransferFcn1_C_n[1] *

    BMS_X.TransferFcn1_CSTATE_ff[1]) + BMS_P.TransferFcn1_C_n[2] *

    BMS_X.TransferFcn1_CSTATE_ff[2]) * BMS_B.Integrator_o * BMS_P.Gain5_Gain_ff)

    * BMS_P.Gain4_Gain_nv;



  /* Sum: '<S52>/Add2' incorporates:

   *  Inport: '<Root>/T'

   *  Inport: '<Root>/U5'

   *  Lookup_n-D: '<S52>/2-D Lookup Table'

   *  Product: '<S52>/Product1'

   *  Sum: '<S52>/Add1'

   */

  rtb_TransferFcn1 = BMS_U.U5 - (BMS_B.Divide1_jl * rtb_Divide3 + look2_binlxpw

    (BMS_B.Integrator_e, BMS_U.T, BMS_P.uDLookupTable_bp01Data_h,

     BMS_P.uDLookupTable_bp02Data_i, BMS_P.uDLookupTable_tableData_f,

     BMS_P.uDLookupTable_maxIndex_e, 21U));



  /* Fcn: '<S54>/abs' incorporates:

   *  Gain: '<S54>/Gain2'

   */

  BMS_B.abs_m = fabs(BMS_P.Gain2_Gain_i * rtb_Divide3);



  /* Lookup_n-D: '<S54>/1-D Lookup Table' incorporates:

   *  Gain: '<S54>/Gain3'

   *  Sum: '<S54>/Add3'

   *  TransferFcn: '<S54>/Transfer Fcn1'

   */

  BMS_B.uDLookupTable_hx = look1_binlxpw((((BMS_P.TransferFcn1_C_mq[0] *

    BMS_X.TransferFcn1_CSTATE_o[0] + BMS_P.TransferFcn1_C_mq[1] *

    BMS_X.TransferFcn1_CSTATE_o[1]) + BMS_P.TransferFcn1_C_mq[2] *

    BMS_X.TransferFcn1_CSTATE_o[2]) + BMS_B.abs_m) * BMS_P.Gain3_Gain_e,

    BMS_P.uDLookupTable_bp01Data_i, BMS_P.uDLookupTable_tableData_fn, 6U);



  /* DeadZone: '<S52>/Dead Zone' */

  if (rtb_TransferFcn1 > BMS_P.DeadZone_End_h) {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_h;

  } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_i) {

    rtb_Add8 = 0.0;

  } else {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_i;

  }



  /* End of DeadZone: '<S52>/Dead Zone' */



  /* Product: '<S52>/Product' incorporates:

   *  Gain: '<S52>/Gain4'

   */

  rtb_Product_o2 = BMS_P.SOCestimator_gainU_m * BMS_B.uDLookupTable_hx *

    rtb_Add8;



  /* Gain: '<S52>/Gain' incorporates:

   *  Product: '<S52>/Divide'

   *  Sum: '<S52>/Sum1'

   */

  BMS_B.Gain_nb = (1.0 / BMS_B.Divide_l2 * rtb_Divide3 + rtb_Product_o2) *

    BMS_P.Gain_Gain_o;



  /* TransferFcn: '<S55>/Transfer Fcn4' */

  BMS_B.TransferFcn4_j = 0.0;

  BMS_B.TransferFcn4_j += BMS_P.TransferFcn4_C_d[0] *

    BMS_X.TransferFcn4_CSTATE_e1[0];

  BMS_B.TransferFcn4_j += BMS_P.TransferFcn4_C_d[1] *

    BMS_X.TransferFcn4_CSTATE_e1[1];

  BMS_B.TransferFcn4_j += BMS_P.TransferFcn4_C_d[2] *

    BMS_X.TransferFcn4_CSTATE_e1[2];



  /* TransferFcn: '<S55>/Transfer Fcn1' */

  rtb_Sqrt = BMS_P.TransferFcn1_C_pi * BMS_X.TransferFcn1_CSTATE_e +

    BMS_P.TransferFcn1_D_h * BMS_B.TransferFcn4_j;



  /* Sqrt: '<S55>/Sqrt'

   *

   * About '<S55>/Sqrt':

   *  Operator: signedSqrt

   */

  if (rtb_Sqrt < 0.0) {

    rtb_Sqrt = -sqrt(fabs(rtb_Sqrt));

  } else {

    rtb_Sqrt = sqrt(rtb_Sqrt);

  }



  /* End of Sqrt: '<S55>/Sqrt' */



  /* Gain: '<S55>/Gain' */

  BMS_B.Gain_pg = BMS_P.Gain_Gain_g3 * rtb_Sqrt;



  /* Product: '<S55>/Product' incorporates:

   *  Gain: '<S55>/Gain1'

   */

  BMS_B.Product_k = BMS_P.Gain1_Gain_h * rtb_Divide3 * rtb_TransferFcn1;



  /* Integrator: '<S56>/Integrator' */

  BMS_B.Integrator_kq = BMS_X.Integrator_CSTATE_l;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S56>/Gain3' */

  BMS_B.Gain3_d = BMS_P.Gain3_Gain_hw * rtb_Product_o2;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S56>/Gain1' incorporates:

   *  Product: '<S56>/Product'

   */

  BMS_B.Gain1_l = BMS_B.Integrator_kq * BMS_B.Gain3_d * BMS_P.Gain1_Gain_g;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S56>/Gain' */

  BMS_B.Gain_nu = BMS_P.Gain_Gain_dc * BMS_B.Gain1_l;



  /* Gain: '<S56>/Gain4' incorporates:

   *  Gain: '<S56>/Gain2'

   *  Gain: '<S56>/Gain5'

   *  Product: '<S56>/Product1'

   *  Sum: '<S56>/Sum'

   *  TransferFcn: '<S56>/Transfer Fcn1'

   */

  BMS_B.Gain4_d = (BMS_P.Gain2_Gain_hz * rtb_Divide3 - ((BMS_P.TransferFcn1_C_b

    [0] * BMS_X.TransferFcn1_CSTATE_gz[0] + BMS_P.TransferFcn1_C_b[1] *

    BMS_X.TransferFcn1_CSTATE_gz[1]) + BMS_P.TransferFcn1_C_b[2] *

    BMS_X.TransferFcn1_CSTATE_gz[2]) * BMS_B.Integrator_kq * BMS_P.Gain5_Gain_g)

    * BMS_P.Gain4_Gain_l;



  /* Sum: '<S57>/Add2' incorporates:

   *  Inport: '<Root>/T'

   *  Inport: '<Root>/U6'

   *  Lookup_n-D: '<S57>/2-D Lookup Table'

   *  Product: '<S57>/Product1'

   *  Sum: '<S57>/Add1'

   */

  rtb_TransferFcn1 = BMS_U.U6 - (BMS_B.Divide1_nb * rtb_Bias + look2_binlxpw

    (BMS_B.Integrator_j, BMS_U.T, BMS_P.uDLookupTable_bp01Data_p,

     BMS_P.uDLookupTable_bp02Data_c, BMS_P.uDLookupTable_tableData_c,

     BMS_P.uDLookupTable_maxIndex_ly, 21U));



  /* Fcn: '<S59>/abs' incorporates:

   *  Gain: '<S59>/Gain2'

   */

  BMS_B.abs_jn = fabs(BMS_P.Gain2_Gain_gw * rtb_Bias);



  /* Lookup_n-D: '<S59>/1-D Lookup Table' incorporates:

   *  Gain: '<S59>/Gain3'

   *  Sum: '<S59>/Add3'

   *  TransferFcn: '<S59>/Transfer Fcn1'

   */

  BMS_B.uDLookupTable_e = look1_binlxpw((((BMS_P.TransferFcn1_C_lj[0] *

    BMS_X.TransferFcn1_CSTATE_h[0] + BMS_P.TransferFcn1_C_lj[1] *

    BMS_X.TransferFcn1_CSTATE_h[1]) + BMS_P.TransferFcn1_C_lj[2] *

    BMS_X.TransferFcn1_CSTATE_h[2]) + BMS_B.abs_jn) * BMS_P.Gain3_Gain_b,

    BMS_P.uDLookupTable_bp01Data_o, BMS_P.uDLookupTable_tableData_d, 6U);



  /* DeadZone: '<S57>/Dead Zone' */

  if (rtb_TransferFcn1 > BMS_P.DeadZone_End_l) {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_l;

  } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_ah) {

    rtb_Add8 = 0.0;

  } else {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_ah;

  }



  /* End of DeadZone: '<S57>/Dead Zone' */



  /* Product: '<S57>/Product' incorporates:

   *  Gain: '<S57>/Gain4'

   */

  rtb_Product_o2 = BMS_P.SOCestimator_gainU_f * BMS_B.uDLookupTable_e * rtb_Add8;



  /* Gain: '<S57>/Gain' incorporates:

   *  Product: '<S57>/Divide'

   *  Sum: '<S57>/Sum1'

   */

  BMS_B.Gain_n1 = (1.0 / BMS_B.Divide_a * rtb_Bias + rtb_Product_o2) *

    BMS_P.Gain_Gain_p;



  /* TransferFcn: '<S60>/Transfer Fcn4' */

  BMS_B.TransferFcn4_a = 0.0;

  BMS_B.TransferFcn4_a += BMS_P.TransferFcn4_C_f[0] *

    BMS_X.TransferFcn4_CSTATE_eg[0];

  BMS_B.TransferFcn4_a += BMS_P.TransferFcn4_C_f[1] *

    BMS_X.TransferFcn4_CSTATE_eg[1];

  BMS_B.TransferFcn4_a += BMS_P.TransferFcn4_C_f[2] *

    BMS_X.TransferFcn4_CSTATE_eg[2];



  /* TransferFcn: '<S60>/Transfer Fcn1' */

  rtb_Sqrt = BMS_P.TransferFcn1_C_i * BMS_X.TransferFcn1_CSTATE_p +

    BMS_P.TransferFcn1_D_e * BMS_B.TransferFcn4_a;



  /* Sqrt: '<S60>/Sqrt'

   *

   * About '<S60>/Sqrt':

   *  Operator: signedSqrt

   */

  if (rtb_Sqrt < 0.0) {

    rtb_Sqrt = -sqrt(fabs(rtb_Sqrt));

  } else {

    rtb_Sqrt = sqrt(rtb_Sqrt);

  }



  /* End of Sqrt: '<S60>/Sqrt' */



  /* Gain: '<S60>/Gain' */

  BMS_B.Gain_f1 = BMS_P.Gain_Gain_fd * rtb_Sqrt;



  /* Product: '<S60>/Product' incorporates:

   *  Gain: '<S60>/Gain1'

   */

  BMS_B.Product_d = BMS_P.Gain1_Gain_le * rtb_Bias * rtb_TransferFcn1;



  /* Integrator: '<S61>/Integrator' */

  BMS_B.Integrator_ie = BMS_X.Integrator_CSTATE_fq;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S61>/Gain3' */

  BMS_B.Gain3_at = BMS_P.Gain3_Gain_c * rtb_Product_o2;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S61>/Gain1' incorporates:

   *  Product: '<S61>/Product'

   */

  BMS_B.Gain1_b = BMS_B.Integrator_ie * BMS_B.Gain3_at * BMS_P.Gain1_Gain_e;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S61>/Gain' */

  BMS_B.Gain_kp = BMS_P.Gain_Gain_i * BMS_B.Gain1_b;



  /* Gain: '<S61>/Gain4' incorporates:

   *  Gain: '<S61>/Gain2'

   *  Gain: '<S61>/Gain5'

   *  Product: '<S61>/Product1'

   *  Sum: '<S61>/Sum'

   *  TransferFcn: '<S61>/Transfer Fcn1'

   */

  BMS_B.Gain4_hb = (BMS_P.Gain2_Gain_hl * rtb_Bias - ((BMS_P.TransferFcn1_C_na[0]

    * BMS_X.TransferFcn1_CSTATE_p5[0] + BMS_P.TransferFcn1_C_na[1] *

    BMS_X.TransferFcn1_CSTATE_p5[1]) + BMS_P.TransferFcn1_C_na[2] *

    BMS_X.TransferFcn1_CSTATE_p5[2]) * BMS_B.Integrator_ie * BMS_P.Gain5_Gain_k)

    * BMS_P.Gain4_Gain_i;



  /* Sum: '<S62>/Add2' incorporates:

   *  Inport: '<Root>/T'

   *  Inport: '<Root>/U7'

   *  Lookup_n-D: '<S62>/2-D Lookup Table'

   *  Product: '<S62>/Product1'

   *  Sum: '<S62>/Add1'

   */

  rtb_TransferFcn1 = BMS_U.U7 - (BMS_B.Divide1_c * rtb_Bias1 + look2_binlxpw

    (BMS_B.Integrator_p, BMS_U.T, BMS_P.uDLookupTable_bp01Data_ng,

     BMS_P.uDLookupTable_bp02Data_f, BMS_P.uDLookupTable_tableData_ft,

     BMS_P.uDLookupTable_maxIndex_es, 21U));



  /* Fcn: '<S64>/abs' incorporates:

   *  Gain: '<S64>/Gain2'

   */

  BMS_B.abs_ms = fabs(BMS_P.Gain2_Gain_ik * rtb_Bias1);



  /* Lookup_n-D: '<S64>/1-D Lookup Table' incorporates:

   *  Gain: '<S64>/Gain3'

   *  Sum: '<S64>/Add3'

   *  TransferFcn: '<S64>/Transfer Fcn1'

   */

  BMS_B.uDLookupTable_n = look1_binlxpw((((BMS_P.TransferFcn1_C_lg[0] *

    BMS_X.TransferFcn1_CSTATE_op[0] + BMS_P.TransferFcn1_C_lg[1] *

    BMS_X.TransferFcn1_CSTATE_op[1]) + BMS_P.TransferFcn1_C_lg[2] *

    BMS_X.TransferFcn1_CSTATE_op[2]) + BMS_B.abs_ms) * BMS_P.Gain3_Gain_jh,

    BMS_P.uDLookupTable_bp01Data_d3, BMS_P.uDLookupTable_tableData_jl, 6U);



  /* DeadZone: '<S62>/Dead Zone' */

  if (rtb_TransferFcn1 > BMS_P.DeadZone_End_c) {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_c;

  } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_ap) {

    rtb_Add8 = 0.0;

  } else {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_ap;

  }



  /* End of DeadZone: '<S62>/Dead Zone' */



  /* Product: '<S62>/Product' incorporates:

   *  Gain: '<S62>/Gain4'

   */

  rtb_Product_o2 = BMS_P.SOCestimator_gainU_a * BMS_B.uDLookupTable_n * rtb_Add8;



  /* Gain: '<S62>/Gain' incorporates:

   *  Product: '<S62>/Divide'

   *  Sum: '<S62>/Sum1'

   */

  BMS_B.Gain_i = (1.0 / BMS_B.Divide_n * rtb_Bias1 + rtb_Product_o2) *

    BMS_P.Gain_Gain_hr;



  /* TransferFcn: '<S65>/Transfer Fcn4' */

  BMS_B.TransferFcn4_ad = 0.0;

  BMS_B.TransferFcn4_ad += BMS_P.TransferFcn4_C_i[0] *

    BMS_X.TransferFcn4_CSTATE_p[0];

  BMS_B.TransferFcn4_ad += BMS_P.TransferFcn4_C_i[1] *

    BMS_X.TransferFcn4_CSTATE_p[1];

  BMS_B.TransferFcn4_ad += BMS_P.TransferFcn4_C_i[2] *

    BMS_X.TransferFcn4_CSTATE_p[2];



  /* TransferFcn: '<S65>/Transfer Fcn1' */

  rtb_Sqrt = BMS_P.TransferFcn1_C_o * BMS_X.TransferFcn1_CSTATE_on +

    BMS_P.TransferFcn1_D_o * BMS_B.TransferFcn4_ad;



  /* Sqrt: '<S65>/Sqrt'

   *

   * About '<S65>/Sqrt':

   *  Operator: signedSqrt

   */

  if (rtb_Sqrt < 0.0) {

    rtb_Sqrt = -sqrt(fabs(rtb_Sqrt));

  } else {

    rtb_Sqrt = sqrt(rtb_Sqrt);

  }



  /* End of Sqrt: '<S65>/Sqrt' */



  /* Gain: '<S65>/Gain' */

  BMS_B.Gain_j = BMS_P.Gain_Gain_gy * rtb_Sqrt;



  /* Product: '<S65>/Product' incorporates:

   *  Gain: '<S65>/Gain1'

   */

  BMS_B.Product_bf = BMS_P.Gain1_Gain_p * rtb_Bias1 * rtb_TransferFcn1;



  /* Integrator: '<S66>/Integrator' */

  BMS_B.Integrator_h1 = BMS_X.Integrator_CSTATE_c;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S66>/Gain3' */

  BMS_B.Gain3_ab = BMS_P.Gain3_Gain_d * rtb_Product_o2;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S66>/Gain1' incorporates:

   *  Product: '<S66>/Product'

   */

  BMS_B.Gain1_e = BMS_B.Integrator_h1 * BMS_B.Gain3_ab * BMS_P.Gain1_Gain_m;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S66>/Gain' */

  BMS_B.Gain_nl = BMS_P.Gain_Gain_gt * BMS_B.Gain1_e;



  /* Gain: '<S66>/Gain4' incorporates:

   *  Gain: '<S66>/Gain2'

   *  Gain: '<S66>/Gain5'

   *  Product: '<S66>/Product1'

   *  Sum: '<S66>/Sum'

   *  TransferFcn: '<S66>/Transfer Fcn1'

   */

  BMS_B.Gain4_g = (BMS_P.Gain2_Gain_k * rtb_Bias1 - ((BMS_P.TransferFcn1_C_mh[0]

    * BMS_X.TransferFcn1_CSTATE_bi[0] + BMS_P.TransferFcn1_C_mh[1] *

    BMS_X.TransferFcn1_CSTATE_bi[1]) + BMS_P.TransferFcn1_C_mh[2] *

    BMS_X.TransferFcn1_CSTATE_bi[2]) * BMS_B.Integrator_h1 * BMS_P.Gain5_Gain_m)

    * BMS_P.Gain4_Gain_o;



  /* Sum: '<S67>/Add2' incorporates:

   *  Inport: '<Root>/T'

   *  Inport: '<Root>/U8'

   *  Lookup_n-D: '<S67>/2-D Lookup Table'

   *  Product: '<S67>/Product1'

   *  Sum: '<S67>/Add1'

   */

  rtb_TransferFcn1 = BMS_U.U8 - (BMS_B.Divide1_i * rtb_Bias2 + look2_binlxpw

    (BMS_B.Integrator_h, BMS_U.T, BMS_P.uDLookupTable_bp01Data_jd,

     BMS_P.uDLookupTable_bp02Data_m, BMS_P.uDLookupTable_tableData_e,

     BMS_P.uDLookupTable_maxIndex_p, 21U));



  /* Fcn: '<S69>/abs' incorporates:

   *  Gain: '<S69>/Gain2'

   */

  BMS_B.abs_b = fabs(BMS_P.Gain2_Gain_k5 * rtb_Bias2);



  /* Lookup_n-D: '<S69>/1-D Lookup Table' incorporates:

   *  Gain: '<S69>/Gain3'

   *  Sum: '<S69>/Add3'

   *  TransferFcn: '<S69>/Transfer Fcn1'

   */

  BMS_B.uDLookupTable_i = look1_binlxpw((((BMS_P.TransferFcn1_C_hm[0] *

    BMS_X.TransferFcn1_CSTATE_d[0] + BMS_P.TransferFcn1_C_hm[1] *

    BMS_X.TransferFcn1_CSTATE_d[1]) + BMS_P.TransferFcn1_C_hm[2] *

    BMS_X.TransferFcn1_CSTATE_d[2]) + BMS_B.abs_b) * BMS_P.Gain3_Gain_ld,

    BMS_P.uDLookupTable_bp01Data_ht, BMS_P.uDLookupTable_tableData_py, 6U);



  /* DeadZone: '<S67>/Dead Zone' */

  if (rtb_TransferFcn1 > BMS_P.DeadZone_End_hq) {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_End_hq;

  } else if (rtb_TransferFcn1 >= BMS_P.DeadZone_Start_e) {

    rtb_Add8 = 0.0;

  } else {

    rtb_Add8 = rtb_TransferFcn1 - BMS_P.DeadZone_Start_e;

  }



  /* End of DeadZone: '<S67>/Dead Zone' */



  /* Product: '<S67>/Product' incorporates:

   *  Gain: '<S67>/Gain4'

   */

  rtb_Product_o2 = BMS_P.SOCestimator_gainU_e * BMS_B.uDLookupTable_i * rtb_Add8;



  /* Gain: '<S67>/Gain' incorporates:

   *  Product: '<S67>/Divide'

   *  Sum: '<S67>/Sum1'

   */

  BMS_B.Gain_iy = (1.0 / BMS_B.Divide_mm * rtb_Bias2 + rtb_Product_o2) *

    BMS_P.Gain_Gain_oq;



  /* TransferFcn: '<S70>/Transfer Fcn4' */

  BMS_B.TransferFcn4_c = 0.0;

  BMS_B.TransferFcn4_c += BMS_P.TransferFcn4_C_o[0] *

    BMS_X.TransferFcn4_CSTATE_mg[0];

  BMS_B.TransferFcn4_c += BMS_P.TransferFcn4_C_o[1] *

    BMS_X.TransferFcn4_CSTATE_mg[1];

  BMS_B.TransferFcn4_c += BMS_P.TransferFcn4_C_o[2] *

    BMS_X.TransferFcn4_CSTATE_mg[2];



  /* TransferFcn: '<S70>/Transfer Fcn1' */

  rtb_Sqrt = BMS_P.TransferFcn1_C_fv * BMS_X.TransferFcn1_CSTATE_hp +

    BMS_P.TransferFcn1_D_j * BMS_B.TransferFcn4_c;



  /* Sqrt: '<S70>/Sqrt'

   *

   * About '<S70>/Sqrt':

   *  Operator: signedSqrt

   */

  if (rtb_Sqrt < 0.0) {

    rtb_Sqrt = -sqrt(fabs(rtb_Sqrt));

  } else {

    rtb_Sqrt = sqrt(rtb_Sqrt);

  }



  /* End of Sqrt: '<S70>/Sqrt' */



  /* Gain: '<S70>/Gain' */

  BMS_B.Gain_bj = BMS_P.Gain_Gain_hw * rtb_Sqrt;



  /* Product: '<S70>/Product' incorporates:

   *  Gain: '<S70>/Gain1'

   */

  BMS_B.Product_h = BMS_P.Gain1_Gain_c4 * rtb_Bias2 * rtb_TransferFcn1;



  /* Integrator: '<S71>/Integrator' */

  BMS_B.Integrator_n = BMS_X.Integrator_CSTATE_e;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S71>/Gain3' */

  BMS_B.Gain3_p = BMS_P.Gain3_Gain_os * rtb_Product_o2;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S71>/Gain1' incorporates:

   *  Product: '<S71>/Product'

   */

  BMS_B.Gain1_g = BMS_B.Integrator_n * BMS_B.Gain3_p * BMS_P.Gain1_Gain_cc;

  if (rtmIsMajorTimeStep(BMS_M)) {

  }



  /* Gain: '<S71>/Gain' */

  BMS_B.Gain_l = BMS_P.Gain_Gain_hf * BMS_B.Gain1_g;



  /* Gain: '<S71>/Gain4' incorporates:

   *  Gain: '<S71>/Gain2'

   *  Gain: '<S71>/Gain5'

   *  Product: '<S71>/Product1'

   *  Sum: '<S71>/Sum'

   *  TransferFcn: '<S71>/Transfer Fcn1'

   */

  BMS_B.Gain4_c = (BMS_P.Gain2_Gain_ht * rtb_Bias2 - ((BMS_P.TransferFcn1_C_hp[0]

    * BMS_X.TransferFcn1_CSTATE_ao[0] + BMS_P.TransferFcn1_C_hp[1] *

    BMS_X.TransferFcn1_CSTATE_ao[1]) + BMS_P.TransferFcn1_C_hp[2] *

    BMS_X.TransferFcn1_CSTATE_ao[2]) * BMS_B.Integrator_n * BMS_P.Gain5_Gain_c) *

    BMS_P.Gain4_Gain_ok;



  /* MATLAB Function: '<S1>/mean' incorporates:

   *  MinMax: '<S1>/MinMax'

   *  SignalConversion generated from: '<S6>/ SFunction '

   */

  rtb_TransferFcn1 = BMS_B.Integrator;

  for (sigIdx = 0; sigIdx < 7; sigIdx++) {

    rtb_TransferFcn1 += tmpForInput_tmp[sigIdx + 1];

  }



  BMS_B.y = rtb_TransferFcn1 / 8.0;

}



/* Model update function */

void BMS_update(void)

{

  int_T idxDelay;

  if (rtmIsMajorTimeStep(BMS_M)) {

    /* Update for Memory: '<Root>/Memory' */

    BMS_DW.Memory_PreviousInput = BMS_B.Add2_a;



    /* Update for Memory: '<Root>/Memory1' */

    BMS_DW.Memory1_PreviousInput = BMS_B.Add2;



    /* Update for Memory: '<Root>/Memory2' */

    BMS_DW.Memory2_PreviousInput = BMS_B.Add2_l;



    /* Update for Memory: '<Root>/Memory3' */

    BMS_DW.Memory3_PreviousInput = BMS_B.Add2_c;



    /* Update for Memory: '<Root>/Memory4' */

    BMS_DW.Memory4_PreviousInput = BMS_B.Add2_c2;



    /* Update for Memory: '<Root>/Memory5' */

    BMS_DW.Memory5_PreviousInput = BMS_B.Add2_m;



    /* Update for Memory: '<Root>/Memory6' */

    BMS_DW.Memory6_PreviousInput = BMS_B.Add2_j;



    /* Update for Memory: '<Root>/Memory7' */

    BMS_DW.Memory7_PreviousInput = BMS_B.Add2_h;



    /* Update for Memory: '<Root>/Memory8' */

    BMS_DW.Memory8_PreviousInput = BMS_B.y;



    /* Update for Memory: '<Root>/Memory10' */

    BMS_DW.Memory10_PreviousInput = BMS_B.Product5;

    for (idxDelay = 0; idxDelay < 9; idxDelay++) {

      /* Update for Delay: '<S3>/Delay' */

      BMS_DW.Delay_DSTATE[idxDelay] = BMS_DW.Delay_DSTATE[idxDelay + 1];



      /* Update for Delay: '<S3>/Delay1' */

      BMS_DW.Delay1_DSTATE[idxDelay] = BMS_DW.Delay1_DSTATE[idxDelay + 1];



      /* Update for Delay: '<S3>/Delay2' */

      BMS_DW.Delay2_DSTATE[idxDelay] = BMS_DW.Delay2_DSTATE[idxDelay + 1];



      /* Update for Delay: '<S3>/Delay3' */

      BMS_DW.Delay3_DSTATE[idxDelay] = BMS_DW.Delay3_DSTATE[idxDelay + 1];

    }



    /* Update for Delay: '<S3>/Delay' */

    BMS_DW.Delay_DSTATE[9] = BMS_B.Relay;



    /* Update for Delay: '<S3>/Delay1' */

    BMS_DW.Delay1_DSTATE[9] = BMS_B.Relay1;



    /* Update for Delay: '<S3>/Delay2' */

    BMS_DW.Delay2_DSTATE[9] = BMS_B.Relay2;



    /* Update for Delay: '<S3>/Delay3' */

    BMS_DW.Delay3_DSTATE[9] = BMS_B.Relay3;

  }



  /* signal main to stop simulation */

  {                                    /* Sample time: [0.0s, 0.0s] */

    if ((rtmGetTFinal(BMS_M)!=-1) &&

        !((rtmGetTFinal(BMS_M)-(((BMS_M->Timing.clockTick1+

             BMS_M->Timing.clockTickH1* 4294967296.0)) * 0.0005)) >

          (((BMS_M->Timing.clockTick1+BMS_M->Timing.clockTickH1* 4294967296.0)) *

           0.0005) * (DBL_EPSILON))) {

      rtmSetErrorStatus(BMS_M, "Simulation finished");

    }

  }



  if (rtmIsMajorTimeStep(BMS_M)) {

    rt_ertODEUpdateContinuousStates(&BMS_M->solverInfo);

  }



  /* Update absolute time for base rate */

  /* The "clockTick0" counts the number of times the code of this task has

   * been executed. The absolute time is the multiplication of "clockTick0"

   * and "Timing.stepSize0". Size of "clockTick0" ensures timer will not

   * overflow during the application lifespan selected.

   * Timer of this task consists of two 32 bit unsigned integers.

   * The two integers represent the low bits Timing.clockTick0 and the high bits

   * Timing.clockTickH0. When the low bit overflows to 0, the high bits increment.

   */

  if (!(++BMS_M->Timing.clockTick0)) {

    ++BMS_M->Timing.clockTickH0;

  }



  BMS_M->Timing.t[0] = rtsiGetSolverStopTime(&BMS_M->solverInfo);



  {

    /* Update absolute timer for sample time: [0.0005s, 0.0s] */

    /* The "clockTick1" counts the number of times the code of this task has

     * been executed. The resolution of this integer timer is 0.0005, which is the step size

     * of the task. Size of "clockTick1" ensures timer will not overflow during the

     * application lifespan selected.

     * Timer of this task consists of two 32 bit unsigned integers.

     * The two integers represent the low bits Timing.clockTick1 and the high bits

     * Timing.clockTickH1. When the low bit overflows to 0, the high bits increment.

     */

    BMS_M->Timing.clockTick1++;

    if (!BMS_M->Timing.clockTick1) {

      BMS_M->Timing.clockTickH1++;

    }

  }

}



/* Derivatives for root system: '<Root>' */

void BMS_derivatives(void)

{

  XDot_BMS_T *_rtXdot;

  _rtXdot = ((XDot_BMS_T *) BMS_M->derivs);



  /* Derivatives for Integrator: '<S32>/Integrator' */

  _rtXdot->Integrator_CSTATE = BMS_B.Gain_p;



  /* Derivatives for Integrator: '<S37>/Integrator' */

  _rtXdot->Integrator_CSTATE_k = BMS_B.Gain_k;



  /* Derivatives for Integrator: '<S42>/Integrator' */

  _rtXdot->Integrator_CSTATE_g = BMS_B.Gain_db;



  /* Derivatives for Integrator: '<S47>/Integrator' */

  _rtXdot->Integrator_CSTATE_f = BMS_B.Gain_pt;



  /* Derivatives for Integrator: '<S52>/Integrator' */

  _rtXdot->Integrator_CSTATE_h = BMS_B.Gain_nb;



  /* Derivatives for Integrator: '<S57>/Integrator' */

  _rtXdot->Integrator_CSTATE_a = BMS_B.Gain_n1;



  /* Derivatives for Integrator: '<S62>/Integrator' */

  _rtXdot->Integrator_CSTATE_n = BMS_B.Gain_i;



  /* Derivatives for Integrator: '<S67>/Integrator' */

  _rtXdot->Integrator_CSTATE_b = BMS_B.Gain_iy;



  /* Derivatives for Integrator: '<S33>/Integrator6' */

  _rtXdot->Integrator6_CSTATE = BMS_B.Gain_e;



  /* Derivatives for Integrator: '<S38>/Integrator6' */

  _rtXdot->Integrator6_CSTATE_h = BMS_B.Gain_n;



  /* Derivatives for Integrator: '<S43>/Integrator6' */

  _rtXdot->Integrator6_CSTATE_d = BMS_B.Gain_f;



  /* Derivatives for Integrator: '<S48>/Integrator6' */

  _rtXdot->Integrator6_CSTATE_g = BMS_B.Gain_nj;



  /* Derivatives for Integrator: '<S53>/Integrator6' */

  _rtXdot->Integrator6_CSTATE_a = BMS_B.Gain_nu;



  /* Derivatives for Integrator: '<S58>/Integrator6' */

  _rtXdot->Integrator6_CSTATE_f = BMS_B.Gain_kp;



  /* Derivatives for Integrator: '<S63>/Integrator6' */

  _rtXdot->Integrator6_CSTATE_hq = BMS_B.Gain_nl;



  /* Derivatives for Integrator: '<S68>/Integrator6' */

  _rtXdot->Integrator6_CSTATE_b = BMS_B.Gain_l;



  /* Derivatives for Integrator: '<S33>/Integrator3' */

  _rtXdot->Integrator3_CSTATE = BMS_B.Gain_d;



  /* Derivatives for Integrator: '<S38>/Integrator3' */

  _rtXdot->Integrator3_CSTATE_i = BMS_B.Gain_c;



  /* Derivatives for Integrator: '<S43>/Integrator3' */

  _rtXdot->Integrator3_CSTATE_h = BMS_B.Gain_h;



  /* Derivatives for Integrator: '<S48>/Integrator3' */

  _rtXdot->Integrator3_CSTATE_hr = BMS_B.Gain_b;



  /* Derivatives for Integrator: '<S53>/Integrator3' */

  _rtXdot->Integrator3_CSTATE_d = BMS_B.Gain_pg;



  /* Derivatives for Integrator: '<S58>/Integrator3' */

  _rtXdot->Integrator3_CSTATE_f = BMS_B.Gain_f1;



  /* Derivatives for Integrator: '<S63>/Integrator3' */

  _rtXdot->Integrator3_CSTATE_dt = BMS_B.Gain_j;



  /* Derivatives for Integrator: '<S68>/Integrator3' */

  _rtXdot->Integrator3_CSTATE_o = BMS_B.Gain_bj;



  /* Derivatives for TransferFcn: '<S34>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE[0] += BMS_P.TransferFcn1_A[0] *

    BMS_X.TransferFcn1_CSTATE[0];

  _rtXdot->TransferFcn1_CSTATE[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE[0] += BMS_P.TransferFcn1_A[1] *

    BMS_X.TransferFcn1_CSTATE[1];

  _rtXdot->TransferFcn1_CSTATE[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE[0] += BMS_P.TransferFcn1_A[2] *

    BMS_X.TransferFcn1_CSTATE[2];

  _rtXdot->TransferFcn1_CSTATE[1] += BMS_X.TransferFcn1_CSTATE[0];

  _rtXdot->TransferFcn1_CSTATE[2] += BMS_X.TransferFcn1_CSTATE[1];

  _rtXdot->TransferFcn1_CSTATE[0] += BMS_B.abs_p;



  /* Derivatives for TransferFcn: '<S35>/Transfer Fcn4' */

  _rtXdot->TransferFcn4_CSTATE[0] = 0.0;

  _rtXdot->TransferFcn4_CSTATE[0] += BMS_P.TransferFcn4_A[0] *

    BMS_X.TransferFcn4_CSTATE[0];

  _rtXdot->TransferFcn4_CSTATE[1] = 0.0;

  _rtXdot->TransferFcn4_CSTATE[0] += BMS_P.TransferFcn4_A[1] *

    BMS_X.TransferFcn4_CSTATE[1];

  _rtXdot->TransferFcn4_CSTATE[2] = 0.0;

  _rtXdot->TransferFcn4_CSTATE[0] += BMS_P.TransferFcn4_A[2] *

    BMS_X.TransferFcn4_CSTATE[2];

  _rtXdot->TransferFcn4_CSTATE[1] += BMS_X.TransferFcn4_CSTATE[0];

  _rtXdot->TransferFcn4_CSTATE[2] += BMS_X.TransferFcn4_CSTATE[1];

  _rtXdot->TransferFcn4_CSTATE[0] += BMS_B.Product;



  /* Derivatives for TransferFcn: '<S35>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_j = 0.0;

  _rtXdot->TransferFcn1_CSTATE_j += BMS_P.TransferFcn1_A_k *

    BMS_X.TransferFcn1_CSTATE_j;

  _rtXdot->TransferFcn1_CSTATE_j += BMS_B.TransferFcn4;



  /* Derivatives for Integrator: '<S36>/Integrator' */

  _rtXdot->Integrator_CSTATE_n5 = BMS_B.Gain4_h;



  /* Derivatives for TransferFcn: '<S36>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_a[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_a[0] += BMS_P.TransferFcn1_A_j[0] *

    BMS_X.TransferFcn1_CSTATE_a[0];

  _rtXdot->TransferFcn1_CSTATE_a[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_a[0] += BMS_P.TransferFcn1_A_j[1] *

    BMS_X.TransferFcn1_CSTATE_a[1];

  _rtXdot->TransferFcn1_CSTATE_a[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_a[0] += BMS_P.TransferFcn1_A_j[2] *

    BMS_X.TransferFcn1_CSTATE_a[2];

  _rtXdot->TransferFcn1_CSTATE_a[1] += BMS_X.TransferFcn1_CSTATE_a[0];

  _rtXdot->TransferFcn1_CSTATE_a[2] += BMS_X.TransferFcn1_CSTATE_a[1];

  _rtXdot->TransferFcn1_CSTATE_a[0] += BMS_B.uDLookupTable;



  /* Derivatives for TransferFcn: '<S39>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_l[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_l[0] += BMS_P.TransferFcn1_A_b[0] *

    BMS_X.TransferFcn1_CSTATE_l[0];

  _rtXdot->TransferFcn1_CSTATE_l[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_l[0] += BMS_P.TransferFcn1_A_b[1] *

    BMS_X.TransferFcn1_CSTATE_l[1];

  _rtXdot->TransferFcn1_CSTATE_l[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_l[0] += BMS_P.TransferFcn1_A_b[2] *

    BMS_X.TransferFcn1_CSTATE_l[2];

  _rtXdot->TransferFcn1_CSTATE_l[1] += BMS_X.TransferFcn1_CSTATE_l[0];

  _rtXdot->TransferFcn1_CSTATE_l[2] += BMS_X.TransferFcn1_CSTATE_l[1];

  _rtXdot->TransferFcn1_CSTATE_l[0] += BMS_B.abs_j;



  /* Derivatives for TransferFcn: '<S40>/Transfer Fcn4' */

  _rtXdot->TransferFcn4_CSTATE_e[0] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_e[0] += BMS_P.TransferFcn4_A_h[0] *

    BMS_X.TransferFcn4_CSTATE_e[0];

  _rtXdot->TransferFcn4_CSTATE_e[1] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_e[0] += BMS_P.TransferFcn4_A_h[1] *

    BMS_X.TransferFcn4_CSTATE_e[1];

  _rtXdot->TransferFcn4_CSTATE_e[2] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_e[0] += BMS_P.TransferFcn4_A_h[2] *

    BMS_X.TransferFcn4_CSTATE_e[2];

  _rtXdot->TransferFcn4_CSTATE_e[1] += BMS_X.TransferFcn4_CSTATE_e[0];

  _rtXdot->TransferFcn4_CSTATE_e[2] += BMS_X.TransferFcn4_CSTATE_e[1];

  _rtXdot->TransferFcn4_CSTATE_e[0] += BMS_B.Product_c;



  /* Derivatives for TransferFcn: '<S40>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_g = 0.0;

  _rtXdot->TransferFcn1_CSTATE_g += BMS_P.TransferFcn1_A_p *

    BMS_X.TransferFcn1_CSTATE_g;

  _rtXdot->TransferFcn1_CSTATE_g += BMS_B.TransferFcn4_h;



  /* Derivatives for Integrator: '<S41>/Integrator' */

  _rtXdot->Integrator_CSTATE_nm = BMS_B.Gain4_k;



  /* Derivatives for TransferFcn: '<S41>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_b[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_b[0] += BMS_P.TransferFcn1_A_f[0] *

    BMS_X.TransferFcn1_CSTATE_b[0];

  _rtXdot->TransferFcn1_CSTATE_b[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_b[0] += BMS_P.TransferFcn1_A_f[1] *

    BMS_X.TransferFcn1_CSTATE_b[1];

  _rtXdot->TransferFcn1_CSTATE_b[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_b[0] += BMS_P.TransferFcn1_A_f[2] *

    BMS_X.TransferFcn1_CSTATE_b[2];

  _rtXdot->TransferFcn1_CSTATE_b[1] += BMS_X.TransferFcn1_CSTATE_b[0];

  _rtXdot->TransferFcn1_CSTATE_b[2] += BMS_X.TransferFcn1_CSTATE_b[1];

  _rtXdot->TransferFcn1_CSTATE_b[0] += BMS_B.uDLookupTable_b;



  /* Derivatives for TransferFcn: '<S44>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_c[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_c[0] += BMS_P.TransferFcn1_A_pq[0] *

    BMS_X.TransferFcn1_CSTATE_c[0];

  _rtXdot->TransferFcn1_CSTATE_c[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_c[0] += BMS_P.TransferFcn1_A_pq[1] *

    BMS_X.TransferFcn1_CSTATE_c[1];

  _rtXdot->TransferFcn1_CSTATE_c[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_c[0] += BMS_P.TransferFcn1_A_pq[2] *

    BMS_X.TransferFcn1_CSTATE_c[2];

  _rtXdot->TransferFcn1_CSTATE_c[1] += BMS_X.TransferFcn1_CSTATE_c[0];

  _rtXdot->TransferFcn1_CSTATE_c[2] += BMS_X.TransferFcn1_CSTATE_c[1];

  _rtXdot->TransferFcn1_CSTATE_c[0] += BMS_B.abs_e;



  /* Derivatives for TransferFcn: '<S45>/Transfer Fcn4' */

  _rtXdot->TransferFcn4_CSTATE_h[0] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_h[0] += BMS_P.TransferFcn4_A_a[0] *

    BMS_X.TransferFcn4_CSTATE_h[0];

  _rtXdot->TransferFcn4_CSTATE_h[1] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_h[0] += BMS_P.TransferFcn4_A_a[1] *

    BMS_X.TransferFcn4_CSTATE_h[1];

  _rtXdot->TransferFcn4_CSTATE_h[2] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_h[0] += BMS_P.TransferFcn4_A_a[2] *

    BMS_X.TransferFcn4_CSTATE_h[2];

  _rtXdot->TransferFcn4_CSTATE_h[1] += BMS_X.TransferFcn4_CSTATE_h[0];

  _rtXdot->TransferFcn4_CSTATE_h[2] += BMS_X.TransferFcn4_CSTATE_h[1];

  _rtXdot->TransferFcn4_CSTATE_h[0] += BMS_B.Product_e;



  /* Derivatives for TransferFcn: '<S45>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_f = 0.0;

  _rtXdot->TransferFcn1_CSTATE_f += BMS_P.TransferFcn1_A_g *

    BMS_X.TransferFcn1_CSTATE_f;

  _rtXdot->TransferFcn1_CSTATE_f += BMS_B.TransferFcn4_o;



  /* Derivatives for Integrator: '<S46>/Integrator' */

  _rtXdot->Integrator_CSTATE_kc = BMS_B.Gain4_i;



  /* Derivatives for TransferFcn: '<S46>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_n[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_n[0] += BMS_P.TransferFcn1_A_h[0] *

    BMS_X.TransferFcn1_CSTATE_n[0];

  _rtXdot->TransferFcn1_CSTATE_n[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_n[0] += BMS_P.TransferFcn1_A_h[1] *

    BMS_X.TransferFcn1_CSTATE_n[1];

  _rtXdot->TransferFcn1_CSTATE_n[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_n[0] += BMS_P.TransferFcn1_A_h[2] *

    BMS_X.TransferFcn1_CSTATE_n[2];

  _rtXdot->TransferFcn1_CSTATE_n[1] += BMS_X.TransferFcn1_CSTATE_n[0];

  _rtXdot->TransferFcn1_CSTATE_n[2] += BMS_X.TransferFcn1_CSTATE_n[1];

  _rtXdot->TransferFcn1_CSTATE_n[0] += BMS_B.uDLookupTable_f;



  /* Derivatives for TransferFcn: '<S49>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_am[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_am[0] += BMS_P.TransferFcn1_A_n[0] *

    BMS_X.TransferFcn1_CSTATE_am[0];

  _rtXdot->TransferFcn1_CSTATE_am[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_am[0] += BMS_P.TransferFcn1_A_n[1] *

    BMS_X.TransferFcn1_CSTATE_am[1];

  _rtXdot->TransferFcn1_CSTATE_am[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_am[0] += BMS_P.TransferFcn1_A_n[2] *

    BMS_X.TransferFcn1_CSTATE_am[2];

  _rtXdot->TransferFcn1_CSTATE_am[1] += BMS_X.TransferFcn1_CSTATE_am[0];

  _rtXdot->TransferFcn1_CSTATE_am[2] += BMS_X.TransferFcn1_CSTATE_am[1];

  _rtXdot->TransferFcn1_CSTATE_am[0] += BMS_B.abs_d;



  /* Derivatives for TransferFcn: '<S50>/Transfer Fcn4' */

  _rtXdot->TransferFcn4_CSTATE_m[0] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_m[0] += BMS_P.TransferFcn4_A_i[0] *

    BMS_X.TransferFcn4_CSTATE_m[0];

  _rtXdot->TransferFcn4_CSTATE_m[1] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_m[0] += BMS_P.TransferFcn4_A_i[1] *

    BMS_X.TransferFcn4_CSTATE_m[1];

  _rtXdot->TransferFcn4_CSTATE_m[2] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_m[0] += BMS_P.TransferFcn4_A_i[2] *

    BMS_X.TransferFcn4_CSTATE_m[2];

  _rtXdot->TransferFcn4_CSTATE_m[1] += BMS_X.TransferFcn4_CSTATE_m[0];

  _rtXdot->TransferFcn4_CSTATE_m[2] += BMS_X.TransferFcn4_CSTATE_m[1];

  _rtXdot->TransferFcn4_CSTATE_m[0] += BMS_B.Product_b;



  /* Derivatives for TransferFcn: '<S50>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_c1 = 0.0;

  _rtXdot->TransferFcn1_CSTATE_c1 += BMS_P.TransferFcn1_A_bo *

    BMS_X.TransferFcn1_CSTATE_c1;

  _rtXdot->TransferFcn1_CSTATE_c1 += BMS_B.TransferFcn4_d;



  /* Derivatives for Integrator: '<S51>/Integrator' */

  _rtXdot->Integrator_CSTATE_fh = BMS_B.Gain4_l;



  /* Derivatives for TransferFcn: '<S51>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_ff[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_ff[0] += BMS_P.TransferFcn1_A_e[0] *

    BMS_X.TransferFcn1_CSTATE_ff[0];

  _rtXdot->TransferFcn1_CSTATE_ff[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_ff[0] += BMS_P.TransferFcn1_A_e[1] *

    BMS_X.TransferFcn1_CSTATE_ff[1];

  _rtXdot->TransferFcn1_CSTATE_ff[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_ff[0] += BMS_P.TransferFcn1_A_e[2] *

    BMS_X.TransferFcn1_CSTATE_ff[2];

  _rtXdot->TransferFcn1_CSTATE_ff[1] += BMS_X.TransferFcn1_CSTATE_ff[0];

  _rtXdot->TransferFcn1_CSTATE_ff[2] += BMS_X.TransferFcn1_CSTATE_ff[1];

  _rtXdot->TransferFcn1_CSTATE_ff[0] += BMS_B.uDLookupTable_h;



  /* Derivatives for TransferFcn: '<S54>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_o[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_o[0] += BMS_P.TransferFcn1_A_k2[0] *

    BMS_X.TransferFcn1_CSTATE_o[0];

  _rtXdot->TransferFcn1_CSTATE_o[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_o[0] += BMS_P.TransferFcn1_A_k2[1] *

    BMS_X.TransferFcn1_CSTATE_o[1];

  _rtXdot->TransferFcn1_CSTATE_o[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_o[0] += BMS_P.TransferFcn1_A_k2[2] *

    BMS_X.TransferFcn1_CSTATE_o[2];

  _rtXdot->TransferFcn1_CSTATE_o[1] += BMS_X.TransferFcn1_CSTATE_o[0];

  _rtXdot->TransferFcn1_CSTATE_o[2] += BMS_X.TransferFcn1_CSTATE_o[1];

  _rtXdot->TransferFcn1_CSTATE_o[0] += BMS_B.abs_m;



  /* Derivatives for TransferFcn: '<S55>/Transfer Fcn4' */

  _rtXdot->TransferFcn4_CSTATE_e1[0] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_e1[0] += BMS_P.TransferFcn4_A_a2[0] *

    BMS_X.TransferFcn4_CSTATE_e1[0];

  _rtXdot->TransferFcn4_CSTATE_e1[1] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_e1[0] += BMS_P.TransferFcn4_A_a2[1] *

    BMS_X.TransferFcn4_CSTATE_e1[1];

  _rtXdot->TransferFcn4_CSTATE_e1[2] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_e1[0] += BMS_P.TransferFcn4_A_a2[2] *

    BMS_X.TransferFcn4_CSTATE_e1[2];

  _rtXdot->TransferFcn4_CSTATE_e1[1] += BMS_X.TransferFcn4_CSTATE_e1[0];

  _rtXdot->TransferFcn4_CSTATE_e1[2] += BMS_X.TransferFcn4_CSTATE_e1[1];

  _rtXdot->TransferFcn4_CSTATE_e1[0] += BMS_B.Product_k;



  /* Derivatives for TransferFcn: '<S55>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_e = 0.0;

  _rtXdot->TransferFcn1_CSTATE_e += BMS_P.TransferFcn1_A_i *

    BMS_X.TransferFcn1_CSTATE_e;

  _rtXdot->TransferFcn1_CSTATE_e += BMS_B.TransferFcn4_j;



  /* Derivatives for Integrator: '<S56>/Integrator' */

  _rtXdot->Integrator_CSTATE_l = BMS_B.Gain4_d;



  /* Derivatives for TransferFcn: '<S56>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_gz[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_gz[0] += BMS_P.TransferFcn1_A_gz[0] *

    BMS_X.TransferFcn1_CSTATE_gz[0];

  _rtXdot->TransferFcn1_CSTATE_gz[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_gz[0] += BMS_P.TransferFcn1_A_gz[1] *

    BMS_X.TransferFcn1_CSTATE_gz[1];

  _rtXdot->TransferFcn1_CSTATE_gz[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_gz[0] += BMS_P.TransferFcn1_A_gz[2] *

    BMS_X.TransferFcn1_CSTATE_gz[2];

  _rtXdot->TransferFcn1_CSTATE_gz[1] += BMS_X.TransferFcn1_CSTATE_gz[0];

  _rtXdot->TransferFcn1_CSTATE_gz[2] += BMS_X.TransferFcn1_CSTATE_gz[1];

  _rtXdot->TransferFcn1_CSTATE_gz[0] += BMS_B.uDLookupTable_hx;



  /* Derivatives for TransferFcn: '<S59>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_h[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_h[0] += BMS_P.TransferFcn1_A_hj[0] *

    BMS_X.TransferFcn1_CSTATE_h[0];

  _rtXdot->TransferFcn1_CSTATE_h[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_h[0] += BMS_P.TransferFcn1_A_hj[1] *

    BMS_X.TransferFcn1_CSTATE_h[1];

  _rtXdot->TransferFcn1_CSTATE_h[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_h[0] += BMS_P.TransferFcn1_A_hj[2] *

    BMS_X.TransferFcn1_CSTATE_h[2];

  _rtXdot->TransferFcn1_CSTATE_h[1] += BMS_X.TransferFcn1_CSTATE_h[0];

  _rtXdot->TransferFcn1_CSTATE_h[2] += BMS_X.TransferFcn1_CSTATE_h[1];

  _rtXdot->TransferFcn1_CSTATE_h[0] += BMS_B.abs_jn;



  /* Derivatives for TransferFcn: '<S60>/Transfer Fcn4' */

  _rtXdot->TransferFcn4_CSTATE_eg[0] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_eg[0] += BMS_P.TransferFcn4_A_j[0] *

    BMS_X.TransferFcn4_CSTATE_eg[0];

  _rtXdot->TransferFcn4_CSTATE_eg[1] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_eg[0] += BMS_P.TransferFcn4_A_j[1] *

    BMS_X.TransferFcn4_CSTATE_eg[1];

  _rtXdot->TransferFcn4_CSTATE_eg[2] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_eg[0] += BMS_P.TransferFcn4_A_j[2] *

    BMS_X.TransferFcn4_CSTATE_eg[2];

  _rtXdot->TransferFcn4_CSTATE_eg[1] += BMS_X.TransferFcn4_CSTATE_eg[0];

  _rtXdot->TransferFcn4_CSTATE_eg[2] += BMS_X.TransferFcn4_CSTATE_eg[1];

  _rtXdot->TransferFcn4_CSTATE_eg[0] += BMS_B.Product_d;



  /* Derivatives for TransferFcn: '<S60>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_p = 0.0;

  _rtXdot->TransferFcn1_CSTATE_p += BMS_P.TransferFcn1_A_ii *

    BMS_X.TransferFcn1_CSTATE_p;

  _rtXdot->TransferFcn1_CSTATE_p += BMS_B.TransferFcn4_a;



  /* Derivatives for Integrator: '<S61>/Integrator' */

  _rtXdot->Integrator_CSTATE_fq = BMS_B.Gain4_hb;



  /* Derivatives for TransferFcn: '<S61>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_p5[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_p5[0] += BMS_P.TransferFcn1_A_he[0] *

    BMS_X.TransferFcn1_CSTATE_p5[0];

  _rtXdot->TransferFcn1_CSTATE_p5[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_p5[0] += BMS_P.TransferFcn1_A_he[1] *

    BMS_X.TransferFcn1_CSTATE_p5[1];

  _rtXdot->TransferFcn1_CSTATE_p5[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_p5[0] += BMS_P.TransferFcn1_A_he[2] *

    BMS_X.TransferFcn1_CSTATE_p5[2];

  _rtXdot->TransferFcn1_CSTATE_p5[1] += BMS_X.TransferFcn1_CSTATE_p5[0];

  _rtXdot->TransferFcn1_CSTATE_p5[2] += BMS_X.TransferFcn1_CSTATE_p5[1];

  _rtXdot->TransferFcn1_CSTATE_p5[0] += BMS_B.uDLookupTable_e;



  /* Derivatives for TransferFcn: '<S64>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_op[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_op[0] += BMS_P.TransferFcn1_A_nn[0] *

    BMS_X.TransferFcn1_CSTATE_op[0];

  _rtXdot->TransferFcn1_CSTATE_op[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_op[0] += BMS_P.TransferFcn1_A_nn[1] *

    BMS_X.TransferFcn1_CSTATE_op[1];

  _rtXdot->TransferFcn1_CSTATE_op[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_op[0] += BMS_P.TransferFcn1_A_nn[2] *

    BMS_X.TransferFcn1_CSTATE_op[2];

  _rtXdot->TransferFcn1_CSTATE_op[1] += BMS_X.TransferFcn1_CSTATE_op[0];

  _rtXdot->TransferFcn1_CSTATE_op[2] += BMS_X.TransferFcn1_CSTATE_op[1];

  _rtXdot->TransferFcn1_CSTATE_op[0] += BMS_B.abs_ms;



  /* Derivatives for TransferFcn: '<S65>/Transfer Fcn4' */

  _rtXdot->TransferFcn4_CSTATE_p[0] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_p[0] += BMS_P.TransferFcn4_A_e[0] *

    BMS_X.TransferFcn4_CSTATE_p[0];

  _rtXdot->TransferFcn4_CSTATE_p[1] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_p[0] += BMS_P.TransferFcn4_A_e[1] *

    BMS_X.TransferFcn4_CSTATE_p[1];

  _rtXdot->TransferFcn4_CSTATE_p[2] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_p[0] += BMS_P.TransferFcn4_A_e[2] *

    BMS_X.TransferFcn4_CSTATE_p[2];

  _rtXdot->TransferFcn4_CSTATE_p[1] += BMS_X.TransferFcn4_CSTATE_p[0];

  _rtXdot->TransferFcn4_CSTATE_p[2] += BMS_X.TransferFcn4_CSTATE_p[1];

  _rtXdot->TransferFcn4_CSTATE_p[0] += BMS_B.Product_bf;



  /* Derivatives for TransferFcn: '<S65>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_on = 0.0;

  _rtXdot->TransferFcn1_CSTATE_on += BMS_P.TransferFcn1_A_o *

    BMS_X.TransferFcn1_CSTATE_on;

  _rtXdot->TransferFcn1_CSTATE_on += BMS_B.TransferFcn4_ad;



  /* Derivatives for Integrator: '<S66>/Integrator' */

  _rtXdot->Integrator_CSTATE_c = BMS_B.Gain4_g;



  /* Derivatives for TransferFcn: '<S66>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_bi[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_bi[0] += BMS_P.TransferFcn1_A_ht[0] *

    BMS_X.TransferFcn1_CSTATE_bi[0];

  _rtXdot->TransferFcn1_CSTATE_bi[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_bi[0] += BMS_P.TransferFcn1_A_ht[1] *

    BMS_X.TransferFcn1_CSTATE_bi[1];

  _rtXdot->TransferFcn1_CSTATE_bi[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_bi[0] += BMS_P.TransferFcn1_A_ht[2] *

    BMS_X.TransferFcn1_CSTATE_bi[2];

  _rtXdot->TransferFcn1_CSTATE_bi[1] += BMS_X.TransferFcn1_CSTATE_bi[0];

  _rtXdot->TransferFcn1_CSTATE_bi[2] += BMS_X.TransferFcn1_CSTATE_bi[1];

  _rtXdot->TransferFcn1_CSTATE_bi[0] += BMS_B.uDLookupTable_n;



  /* Derivatives for TransferFcn: '<S69>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_d[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_d[0] += BMS_P.TransferFcn1_A_hf[0] *

    BMS_X.TransferFcn1_CSTATE_d[0];

  _rtXdot->TransferFcn1_CSTATE_d[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_d[0] += BMS_P.TransferFcn1_A_hf[1] *

    BMS_X.TransferFcn1_CSTATE_d[1];

  _rtXdot->TransferFcn1_CSTATE_d[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_d[0] += BMS_P.TransferFcn1_A_hf[2] *

    BMS_X.TransferFcn1_CSTATE_d[2];

  _rtXdot->TransferFcn1_CSTATE_d[1] += BMS_X.TransferFcn1_CSTATE_d[0];

  _rtXdot->TransferFcn1_CSTATE_d[2] += BMS_X.TransferFcn1_CSTATE_d[1];

  _rtXdot->TransferFcn1_CSTATE_d[0] += BMS_B.abs_b;



  /* Derivatives for TransferFcn: '<S70>/Transfer Fcn4' */

  _rtXdot->TransferFcn4_CSTATE_mg[0] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_mg[0] += BMS_P.TransferFcn4_A_ae[0] *

    BMS_X.TransferFcn4_CSTATE_mg[0];

  _rtXdot->TransferFcn4_CSTATE_mg[1] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_mg[0] += BMS_P.TransferFcn4_A_ae[1] *

    BMS_X.TransferFcn4_CSTATE_mg[1];

  _rtXdot->TransferFcn4_CSTATE_mg[2] = 0.0;

  _rtXdot->TransferFcn4_CSTATE_mg[0] += BMS_P.TransferFcn4_A_ae[2] *

    BMS_X.TransferFcn4_CSTATE_mg[2];

  _rtXdot->TransferFcn4_CSTATE_mg[1] += BMS_X.TransferFcn4_CSTATE_mg[0];

  _rtXdot->TransferFcn4_CSTATE_mg[2] += BMS_X.TransferFcn4_CSTATE_mg[1];

  _rtXdot->TransferFcn4_CSTATE_mg[0] += BMS_B.Product_h;



  /* Derivatives for TransferFcn: '<S70>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_hp = 0.0;

  _rtXdot->TransferFcn1_CSTATE_hp += BMS_P.TransferFcn1_A_c *

    BMS_X.TransferFcn1_CSTATE_hp;

  _rtXdot->TransferFcn1_CSTATE_hp += BMS_B.TransferFcn4_c;



  /* Derivatives for Integrator: '<S71>/Integrator' */

  _rtXdot->Integrator_CSTATE_e = BMS_B.Gain4_c;



  /* Derivatives for TransferFcn: '<S71>/Transfer Fcn1' */

  _rtXdot->TransferFcn1_CSTATE_ao[0] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_ao[0] += BMS_P.TransferFcn1_A_l[0] *

    BMS_X.TransferFcn1_CSTATE_ao[0];

  _rtXdot->TransferFcn1_CSTATE_ao[1] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_ao[0] += BMS_P.TransferFcn1_A_l[1] *

    BMS_X.TransferFcn1_CSTATE_ao[1];

  _rtXdot->TransferFcn1_CSTATE_ao[2] = 0.0;

  _rtXdot->TransferFcn1_CSTATE_ao[0] += BMS_P.TransferFcn1_A_l[2] *

    BMS_X.TransferFcn1_CSTATE_ao[2];

  _rtXdot->TransferFcn1_CSTATE_ao[1] += BMS_X.TransferFcn1_CSTATE_ao[0];

  _rtXdot->TransferFcn1_CSTATE_ao[2] += BMS_X.TransferFcn1_CSTATE_ao[1];

  _rtXdot->TransferFcn1_CSTATE_ao[0] += BMS_B.uDLookupTable_i;

}



/* Model initialize function */

void BMS_initialize(void)

{

  /* Registration code */



  /* initialize non-finites */

  rt_InitInfAndNaN(sizeof(real_T));



  /* initialize real-time model */

  (void) memset((void *)BMS_M, 0,

                sizeof(RT_MODEL_BMS_T));



  {

    /* Setup solver object */

    rtsiSetSimTimeStepPtr(&BMS_M->solverInfo, &BMS_M->Timing.simTimeStep);

    rtsiSetTPtr(&BMS_M->solverInfo, &rtmGetTPtr(BMS_M));

    rtsiSetStepSizePtr(&BMS_M->solverInfo, &BMS_M->Timing.stepSize0);

    rtsiSetdXPtr(&BMS_M->solverInfo, &BMS_M->derivs);

    rtsiSetContStatesPtr(&BMS_M->solverInfo, (real_T **) &BMS_M->contStates);

    rtsiSetNumContStatesPtr(&BMS_M->solverInfo, &BMS_M->Sizes.numContStates);

    rtsiSetNumPeriodicContStatesPtr(&BMS_M->solverInfo,

      &BMS_M->Sizes.numPeriodicContStates);

    rtsiSetPeriodicContStateIndicesPtr(&BMS_M->solverInfo,

      &BMS_M->periodicContStateIndices);

    rtsiSetPeriodicContStateRangesPtr(&BMS_M->solverInfo,

      &BMS_M->periodicContStateRanges);

    rtsiSetErrorStatusPtr(&BMS_M->solverInfo, (&rtmGetErrorStatus(BMS_M)));

    rtsiSetRTModelPtr(&BMS_M->solverInfo, BMS_M);

  }



  rtsiSetSimTimeStep(&BMS_M->solverInfo, MAJOR_TIME_STEP);

  BMS_M->intgData.y = BMS_M->odeY;

  BMS_M->intgData.f[0] = BMS_M->odeF[0];

  BMS_M->intgData.f[1] = BMS_M->odeF[1];

  BMS_M->intgData.f[2] = BMS_M->odeF[2];

  BMS_M->intgData.f[3] = BMS_M->odeF[3];

  BMS_M->contStates = ((X_BMS_T *) &BMS_X);

  rtsiSetSolverData(&BMS_M->solverInfo, (void *)&BMS_M->intgData);

  rtsiSetSolverName(&BMS_M->solverInfo,"ode4");

  rtmSetTPtr(BMS_M, &BMS_M->Timing.tArray[0]);

  rtmSetTFinal(BMS_M, -1);

  BMS_M->Timing.stepSize0 = 0.0005;



  /* Setup for data logging */

  {

    static RTWLogInfo rt_DataLoggingInfo;

    rt_DataLoggingInfo.loggingInterval = NULL;

    BMS_M->rtwLogInfo = &rt_DataLoggingInfo;

  }



  /* Setup for data logging */

  {

    rtliSetLogXSignalInfo(BMS_M->rtwLogInfo, (NULL));

    rtliSetLogXSignalPtrs(BMS_M->rtwLogInfo, (NULL));

    rtliSetLogT(BMS_M->rtwLogInfo, "tout");

    rtliSetLogX(BMS_M->rtwLogInfo, "");

    rtliSetLogXFinal(BMS_M->rtwLogInfo, "");

    rtliSetLogVarNameModifier(BMS_M->rtwLogInfo, "rt_");

    rtliSetLogFormat(BMS_M->rtwLogInfo, 4);

    rtliSetLogMaxRows(BMS_M->rtwLogInfo, 0);

    rtliSetLogDecimation(BMS_M->rtwLogInfo, 1);

    rtliSetLogY(BMS_M->rtwLogInfo, "");

    rtliSetLogYSignalInfo(BMS_M->rtwLogInfo, (NULL));

    rtliSetLogYSignalPtrs(BMS_M->rtwLogInfo, (NULL));

  }



  /* block I/O */

  (void) memset(((void *) &BMS_B), 0,

                sizeof(B_BMS_T));



  /* states (continuous) */

  {

    (void) memset((void *)&BMS_X, 0,

                  sizeof(X_BMS_T));

  }



  /* states (dwork) */

  (void) memset((void *)&BMS_DW, 0,

                sizeof(DW_BMS_T));



  /* external inputs */

  (void)memset(&BMS_U, 0, sizeof(ExtU_BMS_T));



  /* external outputs */

  (void) memset((void *)&BMS_Y, 0,

                sizeof(ExtY_BMS_T));



  /* Initialize DataMapInfo substructure containing ModelMap for C API */

  BMS_InitializeDataMapInfo();



  /* Matfile logging */

  rt_StartDataLoggingWithStartTime(BMS_M->rtwLogInfo, 0.0, rtmGetTFinal(BMS_M),

    BMS_M->Timing.stepSize0, (&rtmGetErrorStatus(BMS_M)));



  {

    int32_T i;



    /* InitializeConditions for Memory: '<Root>/Memory' */

    BMS_DW.Memory_PreviousInput = BMS_P.Memory_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory1' */

    BMS_DW.Memory1_PreviousInput = BMS_P.Memory1_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory2' */

    BMS_DW.Memory2_PreviousInput = BMS_P.Memory2_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory3' */

    BMS_DW.Memory3_PreviousInput = BMS_P.Memory3_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory4' */

    BMS_DW.Memory4_PreviousInput = BMS_P.Memory4_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory5' */

    BMS_DW.Memory5_PreviousInput = BMS_P.Memory5_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory6' */

    BMS_DW.Memory6_PreviousInput = BMS_P.Memory6_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory7' */

    BMS_DW.Memory7_PreviousInput = BMS_P.Memory7_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory8' */

    BMS_DW.Memory8_PreviousInput = BMS_P.Memory8_InitialCondition;



    /* InitializeConditions for Memory: '<Root>/Memory10' */

    BMS_DW.Memory10_PreviousInput = BMS_P.Memory10_InitialCondition;



    /* InitializeConditions for Integrator: '<S32>/Integrator' */

    BMS_X.Integrator_CSTATE = BMS_P.SOCestimator_SOC_init;



    /* InitializeConditions for Integrator: '<S37>/Integrator' */

    BMS_X.Integrator_CSTATE_k = BMS_P.SOCestimator_SOC_init_a;



    /* InitializeConditions for Integrator: '<S42>/Integrator' */

    BMS_X.Integrator_CSTATE_g = BMS_P.SOCestimator_SOC_init_p;



    /* InitializeConditions for Integrator: '<S47>/Integrator' */

    BMS_X.Integrator_CSTATE_f = BMS_P.SOCestimator_SOC_init_b;



    /* InitializeConditions for Integrator: '<S52>/Integrator' */

    BMS_X.Integrator_CSTATE_h = BMS_P.SOCestimator_SOC_init_f;



    /* InitializeConditions for Integrator: '<S57>/Integrator' */

    BMS_X.Integrator_CSTATE_a = BMS_P.SOCestimator_SOC_init_n;



    /* InitializeConditions for Integrator: '<S62>/Integrator' */

    BMS_X.Integrator_CSTATE_n = BMS_P.SOCestimator_SOC_init_ab;



    /* InitializeConditions for Integrator: '<S67>/Integrator' */

    BMS_X.Integrator_CSTATE_b = BMS_P.SOCestimator_SOC_init_g;

    for (i = 0; i < 10; i++) {

      /* InitializeConditions for Delay: '<S3>/Delay' */

      BMS_DW.Delay_DSTATE[i] = BMS_P.Delay_InitialCondition;



      /* InitializeConditions for Delay: '<S3>/Delay1' */

      BMS_DW.Delay1_DSTATE[i] = BMS_P.Delay1_InitialCondition;



      /* InitializeConditions for Delay: '<S3>/Delay2' */

      BMS_DW.Delay2_DSTATE[i] = BMS_P.Delay2_InitialCondition;



      /* InitializeConditions for Delay: '<S3>/Delay3' */

      BMS_DW.Delay3_DSTATE[i] = BMS_P.Delay3_InitialCondition;

    }



    /* InitializeConditions for Integrator: '<S33>/Integrator6' */

    BMS_X.Integrator6_CSTATE = BMS_P.Integrator6_IC;



    /* InitializeConditions for Integrator: '<S38>/Integrator6' */

    BMS_X.Integrator6_CSTATE_h = BMS_P.Integrator6_IC_i;



    /* InitializeConditions for Integrator: '<S43>/Integrator6' */

    BMS_X.Integrator6_CSTATE_d = BMS_P.Integrator6_IC_l;



    /* InitializeConditions for Integrator: '<S48>/Integrator6' */

    BMS_X.Integrator6_CSTATE_g = BMS_P.Integrator6_IC_a;



    /* InitializeConditions for Integrator: '<S53>/Integrator6' */

    BMS_X.Integrator6_CSTATE_a = BMS_P.Integrator6_IC_p;



    /* InitializeConditions for Integrator: '<S58>/Integrator6' */

    BMS_X.Integrator6_CSTATE_f = BMS_P.Integrator6_IC_pg;



    /* InitializeConditions for Integrator: '<S63>/Integrator6' */

    BMS_X.Integrator6_CSTATE_hq = BMS_P.Integrator6_IC_n;



    /* InitializeConditions for Integrator: '<S68>/Integrator6' */

    BMS_X.Integrator6_CSTATE_b = BMS_P.Integrator6_IC_d;



    /* InitializeConditions for Integrator: '<S33>/Integrator3' */

    BMS_X.Integrator3_CSTATE = BMS_P.Integrator3_IC;



    /* InitializeConditions for Integrator: '<S38>/Integrator3' */

    BMS_X.Integrator3_CSTATE_i = BMS_P.Integrator3_IC_n;



    /* InitializeConditions for Integrator: '<S43>/Integrator3' */

    BMS_X.Integrator3_CSTATE_h = BMS_P.Integrator3_IC_d;



    /* InitializeConditions for Integrator: '<S48>/Integrator3' */

    BMS_X.Integrator3_CSTATE_hr = BMS_P.Integrator3_IC_dr;



    /* InitializeConditions for Integrator: '<S53>/Integrator3' */

    BMS_X.Integrator3_CSTATE_d = BMS_P.Integrator3_IC_h;



    /* InitializeConditions for Integrator: '<S58>/Integrator3' */

    BMS_X.Integrator3_CSTATE_f = BMS_P.Integrator3_IC_a;



    /* InitializeConditions for Integrator: '<S63>/Integrator3' */

    BMS_X.Integrator3_CSTATE_dt = BMS_P.Integrator3_IC_i;



    /* InitializeConditions for Integrator: '<S68>/Integrator3' */

    BMS_X.Integrator3_CSTATE_o = BMS_P.Integrator3_IC_j;



    /* InitializeConditions for TransferFcn: '<S34>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S35>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S34>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S35>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S34>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S35>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S35>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_j = 0.0;



    /* InitializeConditions for Integrator: '<S36>/Integrator' */

    BMS_X.Integrator_CSTATE_n5 = BMS_P.Integrator_IC;



    /* InitializeConditions for TransferFcn: '<S36>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_a[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S39>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_l[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S40>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_e[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S36>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_a[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S39>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_l[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S40>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_e[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S36>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_a[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S39>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_l[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S40>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_e[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S40>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_g = 0.0;



    /* InitializeConditions for Integrator: '<S41>/Integrator' */

    BMS_X.Integrator_CSTATE_nm = BMS_P.Integrator_IC_k;



    /* InitializeConditions for TransferFcn: '<S41>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_b[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S44>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_c[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S45>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_h[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S41>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_b[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S44>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_c[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S45>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_h[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S41>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_b[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S44>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_c[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S45>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_h[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S45>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_f = 0.0;



    /* InitializeConditions for Integrator: '<S46>/Integrator' */

    BMS_X.Integrator_CSTATE_kc = BMS_P.Integrator_IC_l;



    /* InitializeConditions for TransferFcn: '<S46>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_n[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S49>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_am[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S50>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_m[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S46>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_n[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S49>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_am[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S50>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_m[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S46>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_n[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S49>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_am[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S50>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_m[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S50>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_c1 = 0.0;



    /* InitializeConditions for Integrator: '<S51>/Integrator' */

    BMS_X.Integrator_CSTATE_fh = BMS_P.Integrator_IC_kj;



    /* InitializeConditions for TransferFcn: '<S51>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_ff[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S54>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_o[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S55>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_e1[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S51>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_ff[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S54>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_o[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S55>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_e1[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S51>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_ff[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S54>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_o[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S55>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_e1[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S55>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_e = 0.0;



    /* InitializeConditions for Integrator: '<S56>/Integrator' */

    BMS_X.Integrator_CSTATE_l = BMS_P.Integrator_IC_i;



    /* InitializeConditions for TransferFcn: '<S56>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_gz[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S59>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_h[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S60>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_eg[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S56>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_gz[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S59>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_h[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S60>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_eg[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S56>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_gz[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S59>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_h[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S60>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_eg[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S60>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_p = 0.0;



    /* InitializeConditions for Integrator: '<S61>/Integrator' */

    BMS_X.Integrator_CSTATE_fq = BMS_P.Integrator_IC_k5;



    /* InitializeConditions for TransferFcn: '<S61>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_p5[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S64>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_op[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S65>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_p[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S61>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_p5[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S64>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_op[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S65>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_p[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S61>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_p5[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S64>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_op[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S65>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_p[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S65>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_on = 0.0;



    /* InitializeConditions for Integrator: '<S66>/Integrator' */

    BMS_X.Integrator_CSTATE_c = BMS_P.Integrator_IC_o;



    /* InitializeConditions for TransferFcn: '<S66>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_bi[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S69>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_d[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S70>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_mg[0] = 0.0;



    /* InitializeConditions for TransferFcn: '<S66>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_bi[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S69>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_d[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S70>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_mg[1] = 0.0;



    /* InitializeConditions for TransferFcn: '<S66>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_bi[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S69>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_d[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S70>/Transfer Fcn4' */

    BMS_X.TransferFcn4_CSTATE_mg[2] = 0.0;



    /* InitializeConditions for TransferFcn: '<S70>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_hp = 0.0;



    /* InitializeConditions for Integrator: '<S71>/Integrator' */

    BMS_X.Integrator_CSTATE_e = BMS_P.Integrator_IC_e;



    /* InitializeConditions for TransferFcn: '<S71>/Transfer Fcn1' */

    BMS_X.TransferFcn1_CSTATE_ao[0] = 0.0;

    BMS_X.TransferFcn1_CSTATE_ao[1] = 0.0;

    BMS_X.TransferFcn1_CSTATE_ao[2] = 0.0;

  }

}



/* Model terminate function */

void BMS_terminate(void)

{

  /* (no terminate code required) */

}