min = rtb_temp153;
      }
      rtb_temp145 = min;
    }

    /* Product Block: <S25>/Weighting */
    rtb_temp145 = (rtP.s25_Weight_Value) *
      rtb_temp145;

    /* MinMax Block: <S25>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_PS_Value[0];
        real_T *y0 = &rtb_s25_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp145;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* Sum Block: <S36>/Sum */
    rtb_temp158 = rtb_temp160 - (rtP.s36_a_Value);
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S36>/Sum1 */
    rtB.s36_b_a = - (rtP.s36_a_Value) + (rtP.s36_b_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Product Block: <S36>/Product ab (trimf) */
    rtb_temp158 = rtb_temp158 /
      rtB.s36_b_a;
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S36>/Sum2 */
    rtB.s36_c_b = - (rtP.s36_b_Value) + (rtP.s36_c_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Sum Block: <S36>/Sum3 */
    rtb_temp160 = (rtP.s36_c_Value) - rtb_temp160;

    /* Product Block: <S36>/Product cd (trimf) */
    rtb_temp160 = 1.0 / rtB.s36_c_b *
      rtb_temp160;

    /* MinMax Block: <S36>/Min (trimf) */
    rtb_temp158 = (rtb_temp158 < rtb_temp160) ? rtb_temp158 : rtb_temp160;

    /* MinMax Block: <S36>/Max (trimf) */
    rtb_temp158 = (rtb_temp158 > (rtP.s36_0_Value)) ? rtb_temp158 : (rtP.s36_0_Value);

    /* MinMax Block: <S26>/andorMethod */
    {
      real_T min = rtb_temp149;

      if (rtb_temp158 < min) {
        min = rtb_temp158;
      }
      rtb_temp149 = min;
    }

    /* Product Block: <S26>/Weighting */
    rtb_temp149 = (rtP.s26_Weight_Value) *
      rtb_temp149;

    /* MinMax Block: <S26>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_ZE_Value[0];
        real_T *y0 = &rtb_s26_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp149;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* Sum Block: <S40>/Sum */
    rtb_temp160 = rtb_temp157 - (rtP.s40_a_Value);
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S40>/Sum1 */
    rtB.s40_b_a = - (rtP.s40_a_Value) + (rtP.s40_b_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Product Block: <S40>/Product ab (trimf) */
    rtb_temp160 = rtb_temp160 /
      rtB.s40_b_a;
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S40>/Sum2 */
    rtB.s40_c_b = - (rtP.s40_b_Value) + (rtP.s40_c_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Sum Block: <S40>/Sum3 */
    rtb_temp146 = (rtP.s40_c_Value) - rtb_temp157;

    /* Product Block: <S40>/Product cd (trimf) */
    rtb_temp146 = 1.0 / rtB.s40_c_b *
      rtb_temp146;

    /* MinMax Block: <S40>/Min (trimf) */
    rtb_temp160 = (rtb_temp160 < rtb_temp146) ? rtb_temp160 : rtb_temp146;

    /* MinMax Block: <S40>/Max (trimf) */
    rtb_temp160 = (rtb_temp160 > (rtP.s40_0_Value)) ? rtb_temp160 : (rtP.s40_0_Value);

    /* MinMax Block: <S27>/andorMethod */
    {
      real_T min = rtb_temp160;

      if (rtb_temp159 < min) {
        min = rtb_temp159;
      }
      rtb_temp146 = min;
    }

    /* Product Block: <S27>/Weighting */
    rtb_temp146 = (rtP.s27_Weight_Value) *
      rtb_temp146;

    /* MinMax Block: <S27>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_PL_Value[0];
        real_T *y0 = &rtb_s27_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp146;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S28>/andorMethod */
    {
      real_T min = rtb_temp160;

      if (rtb_temp151 < min) {
        min = rtb_temp151;
      }
      rtb_temp132 = min;
    }

    /* Product Block: <S28>/Weighting */
    rtb_temp132 = (rtP.s28_Weight_Value) *
      rtb_temp132;

    /* MinMax Block: <S28>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_PS_Value[0];
        real_T *y0 = &rtb_s28_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp132;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S29>/andorMethod */
    {
      real_T min = rtb_temp160;

      if (rtb_temp152 < min) {
        min = rtb_temp152;
      }
      rtb_temp133 = min;
    }

    /* Product Block: <S29>/Weighting */
    rtb_temp133 = (rtP.s29_Weight_Value) *
      rtb_temp133;

    /* MinMax Block: <S29>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_PS_Value[0];
        real_T *y0 = &rtb_s29_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp133;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S30>/andorMethod */
    {
      real_T min = rtb_temp160;

      if (rtb_temp153 < min) {
        min = rtb_temp153;
      }
      rtb_temp134 = min;
    }

    /* Product Block: <S30>/Weighting */
    rtb_temp134 = (rtP.s30_Weight_Value) *
      rtb_temp134;

    /* MinMax Block: <S30>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_ZE_Value[0];
        real_T *y0 = &rtb_s30_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp134;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S7>/andorMethod */
    {
      real_T min = rtb_temp160;

      if (rtb_temp158 < min) {
        min = rtb_temp158;
      }
      rtb_temp160 = min;
    }

    /* Product Block: <S7>/Weighting */
    rtb_temp160 = (rtP.s7_Weight_Value) *
      rtb_temp160;

    /* MinMax Block: <S7>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NS_Value[0];
        real_T *y0 = &rtb_s7_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp160;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* Sum Block: <S43>/Sum */
    rtb_temp154 = rtb_temp157 - (rtP.s43_a_Value);
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S43>/Sum1 */
    rtB.s43_b_a = - (rtP.s43_a_Value) + (rtP.s43_b_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Product Block: <S43>/Product ab (trimf) */
    rtb_temp154 = rtb_temp154 /
      rtB.s43_b_a;
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S43>/Sum2 */
    rtB.s43_c_b = - (rtP.s43_b_Value) + (rtP.s43_c_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Sum Block: <S43>/Sum3 */
    rtb_temp147 = (rtP.s43_c_Value) - rtb_temp157;

    /* Product Block: <S43>/Product cd (trimf) */
    rtb_temp147 = 1.0 / rtB.s43_c_b *
      rtb_temp147;

    /* MinMax Block: <S43>/Min (trimf) */
    rtb_temp154 = (rtb_temp154 < rtb_temp147) ? rtb_temp154 : rtb_temp147;

    /* MinMax Block: <S43>/Max (trimf) */
    rtb_temp154 = (rtb_temp154 > (rtP.s43_0_Value)) ? rtb_temp154 : (rtP.s43_0_Value);

    /* MinMax Block: <S8>/andorMethod */
    {
      real_T min = rtb_temp154;

      if (rtb_temp159 < min) {
        min = rtb_temp159;
      }
      rtb_temp147 = min;
    }

    /* Product Block: <S8>/Weighting */
    rtb_temp147 = (rtP.s8_Weight_Value) *
      rtb_temp147;

    /* MinMax Block: <S8>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_PL_Value[0];
        real_T *y0 = &rtb_s8_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp147;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S9>/andorMethod */
    {
      real_T min = rtb_temp154;

      if (rtb_temp151 < min) {
        min = rtb_temp151;
      }
      rtb_temp135 = min;
    }

    /* Product Block: <S9>/Weighting */
    rtb_temp135 = (rtP.s9_Weight_Value) *
      rtb_temp135;

    /* MinMax Block: <S9>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_PS_Value[0];
        real_T *y0 = &rtb_s9_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp135;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S10>/andorMethod */
    {
      real_T min = rtb_temp154;

      if (rtb_temp152 < min) {
        min = rtb_temp152;
      }
      rtb_temp136 = min;
    }

    /* Product Block: <S10>/Weighting */
    rtb_temp136 = (rtP.s10_Weight_Value) *
      rtb_temp136;

    /* MinMax Block: <S10>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_ZE_Value[0];
        real_T *y0 = &rtb_s10_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp136;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S11>/andorMethod */
    {
      real_T min = rtb_temp154;

      if (rtb_temp153 < min) {
        min = rtb_temp153;
      }
      rtb_temp137 = min;
    }

    /* Product Block: <S11>/Weighting */
    rtb_temp137 = (rtP.s11_Weight_Value) *
      rtb_temp137;

    /* MinMax Block: <S11>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NS_Value[0];
        real_T *y0 = &rtb_s11_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp137;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S12>/andorMethod */
    {
      real_T min = rtb_temp154;

      if (rtb_temp158 < min) {
        min = rtb_temp158;
      }
      rtb_temp154 = min;
    }

    /* Product Block: <S12>/Weighting */
    rtb_temp154 = (rtP.s12_Weight_Value) *
      rtb_temp154;

    /* MinMax Block: <S12>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NL_Value[0];
        real_T *y0 = &rtb_s12_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp154;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* Sum Block: <S42>/Sum */
    rtb_temp155 = rtb_temp157 - (rtP.s42_a_Value);
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S42>/Sum1 */
    rtB.s42_b_a = - (rtP.s42_a_Value) + (rtP.s42_b_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Product Block: <S42>/Product ab (trimf) */
    rtb_temp155 = rtb_temp155 /
      rtB.s42_b_a;
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S42>/Sum2 */
    rtB.s42_c_b = - (rtP.s42_b_Value) + (rtP.s42_c_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Sum Block: <S42>/Sum3 */
    rtb_temp148 = (rtP.s42_c_Value) - rtb_temp157;

    /* Product Block: <S42>/Product cd (trimf) */
    rtb_temp148 = 1.0 / rtB.s42_c_b *
      rtb_temp148;

    /* MinMax Block: <S42>/Min (trimf) */
    rtb_temp155 = (rtb_temp155 < rtb_temp148) ? rtb_temp155 : rtb_temp148;

    /* MinMax Block: <S42>/Max (trimf) */
    rtb_temp155 = (rtb_temp155 > (rtP.s42_0_Value)) ? rtb_temp155 : (rtP.s42_0_Value);

    /* MinMax Block: <S13>/andorMethod */
    {
      real_T min = rtb_temp155;

      if (rtb_temp159 < min) {
        min = rtb_temp159;
      }
      rtb_temp148 = min;
    }

    /* Product Block: <S13>/Weighting */
    rtb_temp148 = (rtP.s13_Weight_Value) *
      rtb_temp148;

    /* MinMax Block: <S13>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_PS_Value[0];
        real_T *y0 = &rtb_s13_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp148;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S14>/andorMethod */
    {
      real_T min = rtb_temp155;

      if (rtb_temp151 < min) {
        min = rtb_temp151;
      }
      rtb_temp138 = min;
    }

    /* Product Block: <S14>/Weighting */
    rtb_temp138 = (rtP.s14_Weight_Value) *
      rtb_temp138;

    /* MinMax Block: <S14>/impMethod */
    {
      real_T min;