/*     delay_len = length(ma_delay_xcorr); */
  /*     ma_M = ma_delay_xcorr(:,1:delay_len)./ma_rx_pwr(:,1:delay_len); */
  /*            */
  /*     % remove delay samples */
  /*     ma_M(:,1:2*D) = []; */
  /*      */
  /*     % combine antennas, if rx diversity is used */
  /*     ma_M = sum(ma_M, 1); */
  /*      */
  /*     if ~sim_options.UseRxDiv */
  /*        threshold = 0.75; */
  /*     else */
  /*        threshold = 1.5; */
  /*     end */
  /*      */
  /*     thres_idx = find(ma_M > threshold); */
  /*     if isempty(thres_idx) */
  /*        thres_idx = 1; */
  /*     else */
  /*        thres_idx = thres_idx(1); */
  /*     end */
  /*      */
  /*  else */
  /*     thres_idx = sim_consts.ExtraNoiseSamples; */
  /*  end; */
  /*   */
  /*  % check if the packet has been detected too late,  */
  /*  % > sim_consts.extra_noise_samples + 35 index  */
  /*  % is out of range of the fine timing algorithm */
  /*  % This prevents simulation error for code running out samples */
  /*  if thres_idx > sim_consts.ExtraNoiseSamples + 35 */
  /*     thres_idx = 1; */
  /*  end */
  /*   */
  /*  detected_packet = rx_signal(:,thres_idx:length(rx_signal)); */
  _SFD_EML_CALL(STATE_DURING_DURING_ACTION_TAG,0,-39);
  sf_debug_pop_symbol_scope();
  for(c1_em_i8 = 0; c1_em_i8 <= 127; c1_em_i8++) {
    c1_syn()[c1_em_i8].re = c1_b_syn[c1_em_i8].re;
    c1_syn()[c1_em_i8].im = c1_b_syn[c1_em_i8].im;
  }
  _SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG,0);
  _sfEvent_ = c1_previousEvent;
  sf_debug_check_for_state_inconsistency();
}

static creal_T c1_times(creal_T c1_x, creal_T c1_y)
{
  creal_T c1_z;
  real_T c1_xr;
  real_T c1_xi;
  real_T c1_yr;
  real_T c1_yi;
  real_T c1_zr;
  real_T c1_zi;
  c1_xr = c1_x.re;
  c1_xi = c1_x.im;
  c1_yr = c1_y.re;
  c1_yi = c1_y.im;
  c1_zr = c1_xr * c1_yr - c1_xi * c1_yi;
  c1_zi = c1_xr * c1_yi + c1_xi * c1_yr;
  c1_z.re = c1_zr;
  c1_z.im = c1_zi;
  return c1_z;
}

static real_T c1_abs(creal_T c1_x)
{
  real_T c1_i;
  real_T c1_b_i;
  real_T c1_xr;
  real_T c1_xi;
  real_T c1_x1;
  real_T c1_x2;
  real_T c1_b_x;
  real_T c1_b_y;
  real_T c1_z;
  real_T c1_c_y;
  real_T c1_t;
  real_T c1_c_x;
  real_T c1_d_y;
  real_T c1_b_x1;
  real_T c1_b_x2;
  real_T c1_d_x;
  real_T c1_e_y;
  real_T c1_b_z;
  real_T c1_f_y;
  real_T c1_e_x;
  real_T c1_g_y;
  c1_i = 1.0;
  c1_b_i = c1_i;
  _SFD_EML_ARRAY_BOUNDS_CHECK("x", (int32_T)_SFD_INTEGER_CHECK("i", c1_b_i), 1,
   1, 1);
  c1_xr = c1_x.re;
  _SFD_EML_ARRAY_BOUNDS_CHECK("x", (int32_T)_SFD_INTEGER_CHECK("i", c1_b_i), 1,
   1, 1);
  c1_xi = c1_x.im;
  if(fabs(c1_xr) > fabs(c1_xi)) {
    c1_x1 = c1_xi;
    c1_x2 = c1_xr;
    c1_b_x = c1_x1;
    c1_b_y = c1_x2;
    c1_z = c1_b_x / c1_b_y;
    c1_c_y = c1_z;
    c1_t = c1_c_y;
    _SFD_EML_ARRAY_BOUNDS_CHECK("y", (int32_T)_SFD_INTEGER_CHECK("i", c1_b_i),
     1, 1, 1);
    c1_c_x = 1.0 + c1_t * c1_t;
    c1_d_y = sqrt(c1_c_x);
    return fabs(c1_xr) * c1_d_y;
  } else if(c1_xi != 0.0) {
    c1_b_x1 = c1_xr;
    c1_b_x2 = c1_xi;
    c1_d_x = c1_b_x1;
    c1_e_y = c1_b_x2;
    c1_b_z = c1_d_x / c1_e_y;
    c1_f_y = c1_b_z;
    c1_t = c1_f_y;
    _SFD_EML_ARRAY_BOUNDS_CHECK("y", (int32_T)_SFD_INTEGER_CHECK("i", c1_b_i),
     1, 1, 1);
    c1_e_x = 1.0 + c1_t * c1_t;
    c1_g_y = sqrt(c1_e_x);
    return fabs(c1_xi) * c1_g_y;
  } else {
    _SFD_EML_ARRAY_BOUNDS_CHECK("y", (int32_T)_SFD_INTEGER_CHECK("i", c1_b_i),
     1, 1, 1);
    return 0.0;
  }
}

static creal_T *c1_syn(void)
{
  return (creal_T *)ssGetOutputPortSignal(chartInstance.S, 1);
}

static creal_T *c1_input_signal(void)
{
  return (creal_T *)ssGetInputPortSignal(chartInstance.S, 0);
}

/* SFunction Glue Code */
void sf_c1_test2_get_check_sum(mxArray *plhs[])
{
  ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(15420601U);
  ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(176772928U);
  ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(397402392U);
  ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2991338647U);
}

mxArray *sf_c1_test2_get_autoinheritance_info(void)
{
  const char *autoinheritanceInfoStructFieldNames[] =
  {"checksum","inputSizes","inputTypes","inputComplexities","parameterSizes","parameterTypes","parameterComplexities","outputSizes","outputTypes","outputComplexities"};
  mxArray *mxAutoinheritanceInfo = NULL;
  mxArray *mxChecksum = NULL;
  mxArray *mxInputSizes = NULL;
  mxArray *mxInputTypes = NULL;
  mxArray *mxInputComplexities = NULL;
  mxArray *mxParameterSizes = NULL;
  mxArray *mxParameterTypes = NULL;
  mxArray *mxParameterComplexities = NULL;
  mxArray *mxOutputSizes = NULL;
  mxArray *mxOutputTypes = NULL;
  mxArray *mxOutputComplexities = NULL;

  mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,
   sizeof(autoinheritanceInfoStructFieldNames)/sizeof(char *),
   autoinheritanceInfoStructFieldNames);

  mxChecksum = mxCreateDoubleMatrix(4,1,mxREAL);
  ((real_T *)mxGetPr((mxChecksum)))[0] = (real_T)(3173348751U);
  ((real_T *)mxGetPr((mxChecksum)))[1] = (real_T)(3536212132U);
  ((real_T *)mxGetPr((mxChecksum)))[2] = (real_T)(1335053314U);
  ((real_T *)mxGetPr((mxChecksum)))[3] = (real_T)(1884663035U);

  mxInputSizes = mxCreateDoubleMatrix(2,1,mxREAL);
  mxInputTypes = mxCreateDoubleMatrix(1,1,mxREAL);
  mxInputComplexities = mxCreateDoubleMatrix(1,1,mxREAL);
  ((real_T *)mxGetPr((mxInputSizes)))[0] = (real_T)(480U);
  ((real_T *)mxGetPr((mxInputSizes)))[1] = (real_T)(1U);
  ((real_T *)mxGetPr((mxInputTypes)))[0] = (real_T)(10U);
  ((real_T *)mxGetPr((mxInputComplexities)))[0] = (real_T)(1U);

  mxParameterSizes = mxCreateDoubleMatrix(2,0,mxREAL);
  mxParameterTypes = mxCreateDoubleMatrix(1,0,mxREAL);
  mxParameterComplexities = mxCreateDoubleMatrix(1,0,mxREAL);

  mxOutputSizes = mxCreateDoubleMatrix(2,1,mxREAL);
  mxOutputTypes = mxCreateDoubleMatrix(1,1,mxREAL);
  mxOutputComplexities = mxCreateDoubleMatrix(1,1,mxREAL);
  ((real_T *)mxGetPr((mxOutputSizes)))[0] = (real_T)(128U);
  ((real_T *)mxGetPr((mxOutputSizes)))[1] = (real_T)(1U);
  ((real_T *)mxGetPr((mxOutputTypes)))[0] = (real_T)(10U);
  ((real_T *)mxGetPr((mxOutputComplexities)))[0] = (real_T)(1U);

  mxSetFieldByNumber(mxAutoinheritanceInfo,0,0,mxChecksum);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,1,mxInputSizes);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,2,mxInputTypes);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,3,mxInputComplexities);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,4,mxParameterSizes);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,5,mxParameterTypes);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,6,mxParameterComplexities);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,7,mxOutputSizes);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,8,mxOutputTypes);
  mxSetFieldByNumber(mxAutoinheritanceInfo,0,9,mxOutputComplexities);

  return(mxAutoinheritanceInfo);
}

static void chart_debug_initialization(SimStruct *S)
{
  if(ssIsFirstInitCond(S)) {
    /* do this only if simulation is starting */
    if(!sim_mode_is_rtw_gen(S)) {
      {
        unsigned int chartAlreadyPresent;
        chartAlreadyPresent = sf_debug_initialize_chart(_test2MachineNumber_,
         1,
         1,
         1,
         2,
         0,
         0,
         0,
         0,
         &(chartInstance.chartNumber),
         &(chartInstance.instanceNumber),
         ssGetPath(S),
         (void *)S);
        if(chartAlreadyPresent==0) {
          /* this is the first instance */
          sf_debug_set_chart_disable_implicit_casting(_test2MachineNumber_,chartInstance.chartNumber,1);
          sf_debug_set_chart_event_thresholds(_test2MachineNumber_,
           chartInstance.chartNumber,
           0,
           0,
           0);

          {
            unsigned int dimVector[1];
            dimVector[0]= 128;
            _SFD_SET_DATA_PROPS(0,2,0,1,SF_DOUBLE,1,&(dimVector[0]),0,0.0,1.0,0,"syn",1);
          }
          {
            unsigned int dimVector[2];
            dimVector[0]= 480;
            dimVector[1]= 1;
            _SFD_SET_DATA_PROPS(1,1,1,0,SF_DOUBLE,2,&(dimVector[0]),0,0.0,1.0,0,"input_signal",1);
          }
          _SFD_STATE_INFO(0,0,2);
          _SFD_CH_SUBSTATE_COUNT(0);
          _SFD_CH_SUBSTATE_DECOMP(0);
        }
        _SFD_CV_INIT_CHART(0,0,0,0);
        {
          _SFD_CV_INIT_STATE(0,0,0,0,0,0,NULL,NULL);
        }

        _SFD_CV_INIT_TRANS(0,0,NULL,NULL,0,NULL);

        /* Initialization of EML Model Coverage */
        _SFD_CV_INIT_EML(0,1,0,0,2,0,0,0);
        _SFD_CV_INIT_EML_FCN(0,0,"eML_blk_kernel",1,-1,4647);
        _SFD_CV_INIT_EML_FOR(0,0,1991,2023,2425);
        _SFD_CV_INIT_EML_FOR(0,1,2091,2102,2242);
        _SFD_TRANS_COV_WTS(0,0,0,1,0);
        if(chartAlreadyPresent==0)
        {
          _SFD_TRANS_COV_MAPS(0,
           0,NULL,NULL,
           0,NULL,NULL,
           1,NULL,NULL,
           0,NULL,NULL);
        }
        _SFD_SET_DATA_VALUE_PTR(0U, c1_syn());
        _SFD_SET_DATA_VALUE_PTR(1U, c1_input_signal());
      }
    }
  } else {
    sf_debug_reset_current_state_configuration(_test2MachineNumber_,chartInstance.chartNumber,chartInstance.instanceNumber);
  }
}

static void sf_opaque_initialize_c1_test2(void *chartInstanceVar)
{
  chart_debug_initialization(chartInstance.S);
  initialize_params_c1_test2();
  initialize_c1_test2();
}

static void sf_opaque_enable_c1_test2(void *chartInstanceVar)
{
  enable_c1_test2();
}

static void sf_opaque_disable_c1_test2(void *chartInstanceVar)
{
  disable_c1_test2();
}

static void sf_opaque_gateway_c1_test2(void *chartInstanceVar)
{
  sf_c1_test2();
}

static void sf_opaque_terminate_c1_test2(void *chartInstanceVar)
{
  finalize_c1_test2();
}

static void mdlProcessParameters_c1_test2(SimStruct *S)
{
  int i;
  for(i=0;i<ssGetNumRunTimeParams(S);i++) {
    ssUpdateDlgParamAsRunTimeParam(S, i);
  }
  initialize_params_c1_test2();
}

static void mdlSetWorkWidths_c1_test2(SimStruct *S)
{
  if(sim_mode_is_rtw_gen(S)) {
    int_T chartIsInlinable =
      (int_T)sf_is_chart_inlinable("test2",1);
    ssSetStateflowIsInlinable(S,chartIsInlinable);
    ssSetEnableFcnIsTrivial(S,1);
    ssSetDisableFcnIsTrivial(S,1);
    ssSetNotMultipleInlinable(S,sf_rtw_info_uint_prop("test2",1,"gatewayCannotBeInlinedMultipleTimes"));
    if(chartIsInlinable) {
      ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);
      sf_mark_chart_expressionable_inputs(S,"test2",1,1);
      sf_mark_chart_reusable_outputs(S,"test2",1,1);
    }
    if (!sf_is_chart_instance_optimized_out("test2",1)) {
      int dtId;
      char *chartInstanceTypedefName =
        sf_chart_instance_typedef_name("test2",1);
      dtId = ssRegisterDataType(S, chartInstanceTypedefName);
      if (dtId == INVALID_DTYPE_ID ) return;
      /* Register the size of the udt */
      if (!ssSetDataTypeSize(S, dtId, 8)) return;
      if(!ssSetNumDWork(S,1)) return;
      ssSetDWorkDataType(S, 0, dtId);
      ssSetDWorkWidth(S, 0, 1);
      ssSetDWorkName(S, 0, "ChartInstance"); /*optional name, less than 16 chars*/
      sf_set_rtw_identifier(S);
    }
    ssSetHasSubFunctions(S,!(chartIsInlinable));
    ssSetOptions(S,ssGetOptions(S)|SS_OPTION_WORKS_WITH_CODE_REUSE);
  }

  ssSetChecksum0(S,(15420601U));
  ssSetChecksum1(S,(176772928U));
  ssSetChecksum2(S,(397402392U));
  ssSetChecksum3(S,(2991338647U));

  ssSetExplicitFCSSCtrl(S,1);
}

static void mdlRTW_c1_test2(SimStruct *S)
{
  if(sim_mode_is_rtw_gen(S)) {
    sf_write_symbol_mapping(S, "test2", 1);
    ssWriteRTWStrParam(S, "StateflowChartType", "Embedded MATLAB");
  }
}

static void mdlStart_c1_test2(SimStruct *S)
{
  chartInstance.chartInfo.chartInstance = NULL;
  chartInstance.chartInfo.isEMLChart = 1;
  chartInstance.chartInfo.chartInitialized = 0;
  chartInstance.chartInfo.sFunctionGateway = sf_opaque_gateway_c1_test2;
  chartInstance.chartInfo.initializeChart = sf_opaque_initialize_c1_test2;
  chartInstance.chartInfo.terminateChart = sf_opaque_terminate_c1_test2;
  chartInstance.chartInfo.enableChart = sf_opaque_enable_c1_test2;
  chartInstance.chartInfo.disableChart = sf_opaque_disable_c1_test2;
  chartInstance.chartInfo.mdlRTW = mdlRTW_c1_test2;
  chartInstance.chartInfo.mdlStart = mdlStart_c1_test2;
  chartInstance.chartInfo.mdlSetWorkWidths = mdlSetWorkWidths_c1_test2;
  chartInstance.chartInfo.restoreLastMajorStepConfiguration = NULL;
  chartInstance.chartInfo.restoreBeforeLastMajorStepConfiguration = NULL;
  chartInstance.chartInfo.storeCurrentConfiguration = NULL;
  chartInstance.S = S;
  ssSetUserData(S,(void *)(&(chartInstance.chartInfo))); /* register the chart instance with simstruct */
}

void c1_test2_method_dispatcher(SimStruct *S, int_T method, void *data)
{
  switch (method) {
   case SS_CALL_MDL_START:
    mdlStart_c1_test2(S);
    break;
   case SS_CALL_MDL_SET_WORK_WIDTHS:
    mdlSetWorkWidths_c1_test2(S);
    break;
   case SS_CALL_MDL_PROCESS_PARAMETERS:
    mdlProcessParameters_c1_test2(S);
    break;
   default:
    /* Unhandled method */
    sf_mex_error_message("Stateflow Internal Error:\n"
     "Error calling c1_test2_method_dispatcher.\n"
     "Can't handle method %d.\n", method);
    break;
  }
}