#if !defined(S_FUNCTION_NAME)
#define S_FUNCTION_NAME                Subsystem_msf
#endif

#define S_FUNCTION_LEVEL               2

#if !defined(RTW_GENERATED_S_FUNCTION)
#define RTW_GENERATED_S_FUNCTION
#endif

#include <stdio.h>
#include <math.h>
#include "simstruc.h"
#include "fixedpoint.h"
#define rt_logging_h
#include "Subsystem_types.h"
#include "Subsystem.h"
#include "Subsystem_private.h"

MdlRefChildMdlRec childModels[1] = {
  "Subsystem", "Subsystem", 0, (NULL) };

static void mdlInitializeSizes(SimStruct *S)
{
  ssSetNumSFcnParams(S, 0);
  ssFxpSetU32BitRegionCompliant(S, 1);
  if (S->mdlInfo->genericFcn != (NULL)) {
    _GenericFcn fcn = S->mdlInfo->genericFcn;
    (fcn)(S, GEN_FCN_CHK_MODELREF_SOLVER_TYPE_EARLY, 2, (NULL));
  }

  ssSetRTWGeneratedSFcn(S, 2);
  ssSetNumContStates(S, 0);
  ssSetNumDiscStates(S, 0);
  if (!ssSetNumInputPorts(S, 1))
    return;
  if (!ssSetInputPortVectorDimension(S, 0, 1))
    return;
  ssSetInputPortDimensionsMode(S, 0, FIXED_DIMS_MODE);
  ssSetInputPortFrameData(S, 0, FRAME_NO);
  if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) {
    ssSetInputPortDataType(S, 0, SS_DOUBLE);
  }

  ssSetInputPortDirectFeedThrough(S, 0, 1);
  ssSetInputPortRequiredContiguous(S, 0, 1);
  ssSetInputPortOptimOpts(S, 0, SS_REUSABLE_AND_LOCAL);
  ssSetInputPortOverWritable(S, 0, FALSE);
  ssSetInputPortSampleTime(S, 0, 0.01);
  ssSetInputPortOffsetTime(S, 0, 0.0);
  if (!ssSetNumOutputPorts(S, 1))
    return;
  if (!ssSetOutputPortVectorDimension(S, 0, 1))
    return;
  ssSetOutputPortDimensionsMode(S, 0, FIXED_DIMS_MODE);
  ssSetOutputPortFrameData(S, 0, FRAME_NO);
  if (ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) {
    ssSetOutputPortDataType(S, 0, SS_DOUBLE);
  }

  ssSetOutputPortSampleTime(S, 0, 0.01);
  ssSetOutputPortOffsetTime(S, 0, 0.0);
  ssSetOutputPortDiscreteValuedOutput(S, 0, 0);
  ssSetOutputPortOkToMerge(S, 0, SS_OK_TO_MERGE);
  ssSetOutputPortOptimOpts(S, 0, SS_NOT_REUSABLE_AND_LOCAL);
  rt_InitInfAndNaN(sizeof(real_T));

  {
    real_T minValue = rtMinusInf;
    real_T maxValue = rtInf;
    ssSetModelRefInputSignalDesignMin(S,0,&minValue);
    ssSetModelRefInputSignalDesignMax(S,0,&maxValue);
  }

  {
    real_T minValue = rtMinusInf;
    real_T maxValue = rtInf;
    ssSetModelRefOutputSignalDesignMin(S,0,&minValue);
    ssSetModelRefOutputSignalDesignMax(S,0,&maxValue);
  }

  {
    static ssRTWStorageType storageClass[2] = { SS_RTW_STORAGE_AUTO,
      SS_RTW_STORAGE_AUTO };

    ssSetModelRefPortRTWStorageClasses(S, storageClass);
  }

  ssSetModelRefSignalLoggingSaveFormat(S, SS_MODEL_DATA_LOGS);
  ssSetNumSampleTimes(S, PORT_BASED_SAMPLE_TIMES);
  ssSetNumRWork(S, 0);
  ssSetNumIWork(S, 0);
  ssSetNumPWork(S, 0);
  ssSetNumModes(S, 0);

  {
    int_T zcsIdx = 0;
  }

  ssSetOutputPortIsNonContinuous(S, 0, 0);
  ssSetOutputPortIsFedByBlockWithModesNoZCs(S, 0, 0);
  ssSetInputPortIsNotDerivPort(S, 0, 1);
  ssSetModelReferenceSampleTimeInheritanceRule(S,
    DISALLOW_SAMPLE_TIME_INHERITANCE);
  ssSetOptimizeModelRefInitCode(S, 1);
  ssSetAcceptsFcnCallInputs(S);
  ssSetModelReferenceNormalModeSupport(S, MDL_START_AND_MDL_PROCESS_PARAMS_OK);
  ssSupportsMultipleExecInstances(S, true);
  ssHasStateInsideForEachSS(S, false);
  ssSetModelRefHasParforForEachSS(S, false);
  ssSetModelRefHasVariantModelOrSubsystem(S, false);
  ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE |
               SS_OPTION_DISALLOW_CONSTANT_SAMPLE_TIME |
               SS_OPTION_SUPPORTS_ALIAS_DATA_TYPES |
               SS_OPTION_WORKS_WITH_CODE_REUSE |
               SS_OPTION_CALL_TERMINATE_ON_EXIT);
  if (S->mdlInfo->genericFcn != (NULL)) {
    ssRegModelRefChildModel(S,1,childModels);
  }

#if SS_SFCN_FOR_SIM

  if (S->mdlInfo->genericFcn != (NULL) &&
      ssGetSimMode(S) != SS_SIMMODE_SIZES_CALL_ONLY) {
    int_T retVal = 1;
    mr_Subsystem_MdlInfoRegFcn(S, "Subsystem", &retVal);
    if (!retVal)
      return;
  }

#endif

  if (!ssSetNumDWork(S, 1)) {
    return;
  }

#if SS_SFCN_FOR_SIM

  {
    int mdlrefDWTypeId;
    ssRegMdlRefDWorkType(S, &mdlrefDWTypeId);
    if (mdlrefDWTypeId == INVALID_DTYPE_ID )
      return;
    if (!ssSetDataTypeSize(S, mdlrefDWTypeId, sizeof(rtMdlrefDWork_mr_Subsystem)))
      return;
    ssSetDWorkDataType(S, 0, mdlrefDWTypeId);
    ssSetDWorkWidth(S, 0, 1);
  }

#endif

}

static void mdlInitializeSampleTimes(SimStruct *S)
{
}

#define MDL_SET_INPUT_PORT_SAMPLE_TIME
#if defined(MATLAB_MEX_FILE)

static void mdlSetInputPortSampleTime(SimStruct *S,int_T portIdx,real_T
  sampleTime,real_T offsetTime)
{
  int i;
  for (i = 0 ; i < 1; ++i) {
    ssSetInputPortSampleTime(S,i,sampleTime);
    ssSetInputPortOffsetTime(S,i,offsetTime);
  }

  for (i = 0 ; i < 1; ++i) {
    if (ssGetOutputPortSampleTime(S,i) == rtInf &&
        ssGetOutputPortOffsetTime(S,i) == 0.0) {
      continue;
    }

    ssSetOutputPortSampleTime(S,i,sampleTime);
    ssSetOutputPortOffsetTime(S,i,offsetTime);
  }
}

#endif

#define MDL_SET_OUTPUT_PORT_SAMPLE_TIME
#if defined(MATLAB_MEX_FILE)

static void mdlSetOutputPortSampleTime(SimStruct *S,int_T portIdx,real_T
  sampleTime,real_T offsetTime)
{
  int i;
  for (i = 0 ; i < 1; ++i) {
    ssSetInputPortSampleTime(S,i,sampleTime);
    ssSetInputPortOffsetTime(S,i,offsetTime);
  }

  for (i = 0 ; i < 1; ++i) {
    if (ssGetOutputPortSampleTime(S,i) == rtInf &&
        ssGetOutputPortOffsetTime(S,i) == 0.0) {
      continue;
    }

    ssSetOutputPortSampleTime(S,i,sampleTime);
    ssSetOutputPortOffsetTime(S,i,offsetTime);
  }
}

#endif

#define MDL_SET_WORK_WIDTHS

static void mdlSetWorkWidths(SimStruct *S)
{
  if (S->mdlInfo->genericFcn != (NULL)) {
    real_T stopTime = 10.0;
    int_T hwSettings[13];
    int_T opSettings[1];
    _GenericFcn fcn = S->mdlInfo->genericFcn;
    boolean_T hasDiscTs = 1;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_SOLVER_TYPE, 2, &hasDiscTs))
      return;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_SOLVER_NAME, 2, (void *)
               "FixedStepDiscrete"))
      return;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_SOLVER_MODE, SOLVER_MODE_SINGLETASKING,
               (NULL)))
      return;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_STOP_TIME, -1, &stopTime))
      return;
    hwSettings[0] = 8;
    hwSettings[1] = 16;
    hwSettings[2] = 32;
    hwSettings[3] = 32;
    hwSettings[4] = 32;
    hwSettings[5] = 64;
    hwSettings[6] = 32;
    hwSettings[7] = 2;
    hwSettings[8] = 0;
    hwSettings[9] = 32;
    hwSettings[10] = 1;
    hwSettings[11] = 0;
    hwSettings[12] = 2;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_HARDWARE_SETTINGS, 13, hwSettings))
      return;
    opSettings[0] = 0;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_OPTIM_SETTINGS, 1, opSettings))
      return;
    ssSetSignalSizesComputeType(S, SS_VARIABLE_SIZE_FROM_INPUT_VALUE_AND_SIZE);
  }

  {
    static const char* toFileNames[] = { "" };

    static const char* fromFileNames[] = { "" };

    if (!ssSetModelRefFromFiles(S, 0,fromFileNames))
      return;
    if (!ssSetModelRefToFiles(S, 0,toFileNames))
      return;
  }
}

#define MDL_START

static void mdlStart(SimStruct *S)
{
  rtMdlrefDWork_mr_Subsystem *dw = (rtMdlrefDWork_mr_Subsystem *) ssGetDWork(S,
    0);
  void *sysRanPtr = (NULL);
  int sysTid = 0;
  ssGetContextSysRanBCPtr(S, &sysRanPtr);
  ssGetContextSysTid(S, &sysTid);
  mr_Subsystem_initialize(S, ssGetSampleTimeTaskID(S, 0), &(dw->rtm), sysRanPtr,
    sysTid, (NULL), (NULL), 0, -1);
  ssSetModelMappingInfoPtr(S, &(dw->rtm.DataMapInfo.mmi));
  if (S->mdlInfo->genericFcn != (NULL)) {
    _GenericFcn fcn = S->mdlInfo->genericFcn;
    boolean_T hasDiscTs = 1;
    real_T startTime = 0.0;
    real_T lifeSpan = 1.0;
    boolean_T concurrTaskSupport = 0;
    real_T fixedStep = 0.01;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_LIFE_SPAN, -1, &lifeSpan))
      return;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_START_TIME, -1, &startTime))
      return;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_FIXED_STEP, (int_T)hasDiscTs, &fixedStep))
      return;
    if (!(fcn)(S, GEN_FCN_CHK_MODELREF_CONCURRETNT_TASK_SUPPORT, (int_T)
               concurrTaskSupport, NULL))
      return;
  }
}

static void mdlOutputs(SimStruct *S, int_T tid)
{
  const real_T *InPort_0 = (real_T *) ssGetInputPortSignal(S, 0);
  real_T *OutPort_0 = (real_T *) ssGetOutputPortSignal(S, 0);
  rtMdlrefDWork_mr_Subsystem *dw = (rtMdlrefDWork_mr_Subsystem *) ssGetDWork(S,
    0);
  if (tid != CONSTANT_TID) {
    mr_Subsystem(InPort_0, OutPort_0);
  }
}

static void mdlTerminate(SimStruct *S)
{
  rtMdlrefDWork_mr_Subsystem *dw = (rtMdlrefDWork_mr_Subsystem *) ssGetDWork(S,
    0);
}

#ifdef MATLAB_MEX_FILE
#include "simulink.c"
#include "fixedpoint.c"
#else
#include "cg_sfun.h"
#endif