From 3ed1b56a865e09b37b72aa9bbf4457d455765100 Mon Sep 17 00:00:00 2001
From: Emilio Corigliano <emilio.corigliano@skywarder.eu>
Date: Wed, 25 Oct 2023 18:41:07 +0200
Subject: [PATCH] [Coder][ADA] Inserted the autocoded and packed ADA files

---
 .../ADA/run_ADA_grt_rtw/CMakeLists.txt        |  105 ++
 .../run_ADA/ADA/run_ADA_grt_rtw/buildInfo.mat |  Bin 0 -> 25213 bytes
 .../ADA/run_ADA_grt_rtw/multiword_types.h     | 1167 +++++++++++++++++
 .../run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h     |   39 +
 .../run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h    |   41 +
 .../run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp   |  347 +++++
 .../run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h     |  212 +++
 .../ADA/run_ADA_grt_rtw/run_ADA_data.cpp      |   41 +
 .../ADA/run_ADA_grt_rtw/run_ADA_private.h     |   26 +
 .../ADA/run_ADA_grt_rtw/run_ADA_types.h       |   43 +
 .../run_ADA/R2023a/extern/include/tmwtypes.h  |  888 +++++++++++++
 .../rtw/c/src/common/rt_cppclass_main.cpp     |  452 +++++++
 .../rtw/c/src/ext_mode/common/ext_work.h      |  127 ++
 .../run_ADA/R2023a/rtw/c/src/rt_logging.h     |  290 ++++
 .../R2023a/simulink/include/rtw_continuous.h  |  109 ++
 .../R2023a/simulink/include/rtw_solver.h      |  292 +++++
 16 files changed, 4179 insertions(+)
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/CMakeLists.txt
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/buildInfo.mat
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/multiword_types.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_data.cpp
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_private.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_types.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/extern/include/tmwtypes.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/common/rt_cppclass_main.cpp
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/ext_mode/common/ext_work.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/rt_logging.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_continuous.h
 create mode 100644 src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_solver.h

diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/CMakeLists.txt b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/CMakeLists.txt
new file mode 100644
index 000000000..9218d4ba5
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/CMakeLists.txt
@@ -0,0 +1,105 @@
+######################################################################
+# CMakeLists.txt generated for component run_ADA
+# Product type: executable
+######################################################################
+cmake_minimum_required(VERSION 3.12)
+project(run_ADA)
+if(DEFINED ENV{CMAKE_EXPORT_COMPILE_COMMANDS} AND NOT DEFINED CMAKE_EXPORT_COMPILE_COMMANDS)
+    set(CMAKE_EXPORT_COMPILE_COMMANDS $ENV{CMAKE_EXPORT_COMPILE_COMMANDS})
+endif()
+
+
+######################################################################
+## Path variables
+######################################################################
+get_filename_component(START_DIR .. ABSOLUTE)
+set(MATLAB_ROOT C:/Program\ Files/MATLAB/R2023a CACHE PATH "")
+if(${CMAKE_CURRENT_BINARY_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
+    set(BUILDING_IN_SOURCE_DIR TRUE)
+    set(BINARY_START_DIR "${START_DIR}")
+else()
+    set(BUILDING_IN_SOURCE_DIR FALSE)
+    set(BINARY_START_DIR "${CMAKE_BINARY_DIR}")
+endif()
+if(WIN32 AND NOT MINGW)
+    set(SYSLIB_PREFIX "lib")
+else()
+    set(SYSLIB_PREFIX "")
+endif()
+
+######################################################################
+## System libraries
+######################################################################
+find_library(FOUND_LIBM m NO_SYSTEM_ENVIRONMENT_PATH PATHS ${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}
+    ${CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES})
+
+######################################################################
+## Target definition and commands
+######################################################################
+add_executable(run_ADA  ${START_DIR}/run_ADA_grt_rtw/run_ADA.cpp
+    ${START_DIR}/run_ADA_grt_rtw/run_ADA_data.cpp
+    ${MATLAB_ROOT}/rtw/c/src/common/rt_cppclass_main.cpp)
+set_target_properties(run_ADA PROPERTIES
+    PREFIX ""
+    POSITION_INDEPENDENT_CODE ON
+    RUNTIME_OUTPUT_DIRECTORY "${BINARY_START_DIR}/./$<0:>"
+    LIBRARY_OUTPUT_DIRECTORY "${BINARY_START_DIR}/./$<0:>"
+    ARCHIVE_OUTPUT_DIRECTORY "${BINARY_START_DIR}/./$<0:>")
+target_compile_features(run_ADA PUBLIC cxx_std_11)
+target_compile_definitions(run_ADA PRIVATE -DMODEL=run_ADA
+    -DNUMST=1
+    -DNCSTATES=0
+    -DHAVESTDIO
+    -DRT
+    -DUSE_RTMODEL
+    -DCLASSIC_INTERFACE=0
+    -DALLOCATIONFCN=0
+    -DTID01EQ=0
+    -DMAT_FILE=0
+    -DONESTEPFCN=1
+    -DTERMFCN=1
+    -DMULTI_INSTANCE_CODE=1
+    -DINTEGER_CODE=0
+    -DMT=0)
+target_include_directories(run_ADA PRIVATE ${START_DIR}
+    ${START_DIR}/run_ADA_grt_rtw
+    ${MATLAB_ROOT}/extern/include
+    ${MATLAB_ROOT}/simulink/include
+    ${MATLAB_ROOT}/rtw/c/src
+    ${MATLAB_ROOT}/rtw/c/src/ext_mode/common)
+target_link_libraries(run_ADA PRIVATE $<$<BOOL:${FOUND_LIBM}>:m>)
+if(WIN32)
+   target_link_libraries(run_ADA PRIVATE kernel32
+       ws2_32
+       mswsock
+       advapi32)
+endif()
+
+######################################################################
+## Extract debug symbols
+######################################################################
+if(APPLE AND (CMAKE_C_COMPILER_ID STREQUAL "AppleClang"))
+    string(APPEND _dsymutilcmd "$<IF:$<CONFIG:DEBUG,RELWITHDEBINFO>,"
+                "xcrun;dsymutil;$<TARGET_FILE:run_ADA>;--flat,"
+                "true"
+        >)
+    add_custom_command(TARGET run_ADA
+            POST_BUILD
+            COMMAND "${_dsymutilcmd}"
+            COMMAND_EXPAND_LISTS
+            BYPRODUCTS run_ADA.dwarf)
+endif()
+
+
+######################################################################
+## Build success message
+######################################################################
+add_custom_command(TARGET run_ADA POST_BUILD
+     COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --cyan "\\#\\#\\# Created executable: $<TARGET_FILE:run_ADA>")
+
+######################################################################
+## Call toolchain hook function if defined
+######################################################################
+if(COMMAND toolchain_target_hook)
+    toolchain_target_hook(run_ADA)
+endif()
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/buildInfo.mat b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/buildInfo.mat
new file mode 100644
index 0000000000000000000000000000000000000000..003c26d1bbf82b717b08edb897e43d006ab0bba0
GIT binary patch
literal 25213
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
A761SM

literal 0
HcmV?d00001

diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/multiword_types.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/multiword_types.h
new file mode 100644
index 000000000..7baddd213
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/multiword_types.h
@@ -0,0 +1,1167 @@
+/*
+ * multiword_types.h
+ *
+ * Academic License - for use in teaching, academic research, and meeting
+ * course requirements at degree granting institutions only.  Not for
+ * government, commercial, or other organizational use.
+ *
+ * Code generation for model "run_ADA".
+ *
+ * Model version              : 1.25
+ * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022
+ * C++ source code generated on : Wed Oct 25 17:58:39 2023
+ *
+ * Target selection: grt.tlc
+ * Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: Intel->x86-64 (Windows64)
+ * Code generation objective: Execution efficiency
+ * Validation result: Not run
+ */
+
+#ifndef MULTIWORD_TYPES_H
+#define MULTIWORD_TYPES_H
+#include "rtwtypes.h"
+
+/*
+ * MultiWord supporting definitions
+ */
+typedef long int long_T;
+
+/*
+ * MultiWord types
+ */
+typedef struct {
+  uint32_T chunks[2];
+} int64m_T;
+
+typedef struct {
+  int64m_T re;
+  int64m_T im;
+} cint64m_T;
+
+typedef struct {
+  uint32_T chunks[2];
+} uint64m_T;
+
+typedef struct {
+  uint64m_T re;
+  uint64m_T im;
+} cuint64m_T;
+
+typedef struct {
+  uint32_T chunks[3];
+} int96m_T;
+
+typedef struct {
+  int96m_T re;
+  int96m_T im;
+} cint96m_T;
+
+typedef struct {
+  uint32_T chunks[3];
+} uint96m_T;
+
+typedef struct {
+  uint96m_T re;
+  uint96m_T im;
+} cuint96m_T;
+
+typedef struct {
+  uint32_T chunks[4];
+} int128m_T;
+
+typedef struct {
+  int128m_T re;
+  int128m_T im;
+} cint128m_T;
+
+typedef struct {
+  uint32_T chunks[4];
+} uint128m_T;
+
+typedef struct {
+  uint128m_T re;
+  uint128m_T im;
+} cuint128m_T;
+
+typedef struct {
+  uint32_T chunks[5];
+} int160m_T;
+
+typedef struct {
+  int160m_T re;
+  int160m_T im;
+} cint160m_T;
+
+typedef struct {
+  uint32_T chunks[5];
+} uint160m_T;
+
+typedef struct {
+  uint160m_T re;
+  uint160m_T im;
+} cuint160m_T;
+
+typedef struct {
+  uint32_T chunks[6];
+} int192m_T;
+
+typedef struct {
+  int192m_T re;
+  int192m_T im;
+} cint192m_T;
+
+typedef struct {
+  uint32_T chunks[6];
+} uint192m_T;
+
+typedef struct {
+  uint192m_T re;
+  uint192m_T im;
+} cuint192m_T;
+
+typedef struct {
+  uint32_T chunks[7];
+} int224m_T;
+
+typedef struct {
+  int224m_T re;
+  int224m_T im;
+} cint224m_T;
+
+typedef struct {
+  uint32_T chunks[7];
+} uint224m_T;
+
+typedef struct {
+  uint224m_T re;
+  uint224m_T im;
+} cuint224m_T;
+
+typedef struct {
+  uint32_T chunks[8];
+} int256m_T;
+
+typedef struct {
+  int256m_T re;
+  int256m_T im;
+} cint256m_T;
+
+typedef struct {
+  uint32_T chunks[8];
+} uint256m_T;
+
+typedef struct {
+  uint256m_T re;
+  uint256m_T im;
+} cuint256m_T;
+
+typedef struct {
+  uint32_T chunks[9];
+} int288m_T;
+
+typedef struct {
+  int288m_T re;
+  int288m_T im;
+} cint288m_T;
+
+typedef struct {
+  uint32_T chunks[9];
+} uint288m_T;
+
+typedef struct {
+  uint288m_T re;
+  uint288m_T im;
+} cuint288m_T;
+
+typedef struct {
+  uint32_T chunks[10];
+} int320m_T;
+
+typedef struct {
+  int320m_T re;
+  int320m_T im;
+} cint320m_T;
+
+typedef struct {
+  uint32_T chunks[10];
+} uint320m_T;
+
+typedef struct {
+  uint320m_T re;
+  uint320m_T im;
+} cuint320m_T;
+
+typedef struct {
+  uint32_T chunks[11];
+} int352m_T;
+
+typedef struct {
+  int352m_T re;
+  int352m_T im;
+} cint352m_T;
+
+typedef struct {
+  uint32_T chunks[11];
+} uint352m_T;
+
+typedef struct {
+  uint352m_T re;
+  uint352m_T im;
+} cuint352m_T;
+
+typedef struct {
+  uint32_T chunks[12];
+} int384m_T;
+
+typedef struct {
+  int384m_T re;
+  int384m_T im;
+} cint384m_T;
+
+typedef struct {
+  uint32_T chunks[12];
+} uint384m_T;
+
+typedef struct {
+  uint384m_T re;
+  uint384m_T im;
+} cuint384m_T;
+
+typedef struct {
+  uint32_T chunks[13];
+} int416m_T;
+
+typedef struct {
+  int416m_T re;
+  int416m_T im;
+} cint416m_T;
+
+typedef struct {
+  uint32_T chunks[13];
+} uint416m_T;
+
+typedef struct {
+  uint416m_T re;
+  uint416m_T im;
+} cuint416m_T;
+
+typedef struct {
+  uint32_T chunks[14];
+} int448m_T;
+
+typedef struct {
+  int448m_T re;
+  int448m_T im;
+} cint448m_T;
+
+typedef struct {
+  uint32_T chunks[14];
+} uint448m_T;
+
+typedef struct {
+  uint448m_T re;
+  uint448m_T im;
+} cuint448m_T;
+
+typedef struct {
+  uint32_T chunks[15];
+} int480m_T;
+
+typedef struct {
+  int480m_T re;
+  int480m_T im;
+} cint480m_T;
+
+typedef struct {
+  uint32_T chunks[15];
+} uint480m_T;
+
+typedef struct {
+  uint480m_T re;
+  uint480m_T im;
+} cuint480m_T;
+
+typedef struct {
+  uint32_T chunks[16];
+} int512m_T;
+
+typedef struct {
+  int512m_T re;
+  int512m_T im;
+} cint512m_T;
+
+typedef struct {
+  uint32_T chunks[16];
+} uint512m_T;
+
+typedef struct {
+  uint512m_T re;
+  uint512m_T im;
+} cuint512m_T;
+
+typedef struct {
+  uint32_T chunks[17];
+} int544m_T;
+
+typedef struct {
+  int544m_T re;
+  int544m_T im;
+} cint544m_T;
+
+typedef struct {
+  uint32_T chunks[17];
+} uint544m_T;
+
+typedef struct {
+  uint544m_T re;
+  uint544m_T im;
+} cuint544m_T;
+
+typedef struct {
+  uint32_T chunks[18];
+} int576m_T;
+
+typedef struct {
+  int576m_T re;
+  int576m_T im;
+} cint576m_T;
+
+typedef struct {
+  uint32_T chunks[18];
+} uint576m_T;
+
+typedef struct {
+  uint576m_T re;
+  uint576m_T im;
+} cuint576m_T;
+
+typedef struct {
+  uint32_T chunks[19];
+} int608m_T;
+
+typedef struct {
+  int608m_T re;
+  int608m_T im;
+} cint608m_T;
+
+typedef struct {
+  uint32_T chunks[19];
+} uint608m_T;
+
+typedef struct {
+  uint608m_T re;
+  uint608m_T im;
+} cuint608m_T;
+
+typedef struct {
+  uint32_T chunks[20];
+} int640m_T;
+
+typedef struct {
+  int640m_T re;
+  int640m_T im;
+} cint640m_T;
+
+typedef struct {
+  uint32_T chunks[20];
+} uint640m_T;
+
+typedef struct {
+  uint640m_T re;
+  uint640m_T im;
+} cuint640m_T;
+
+typedef struct {
+  uint32_T chunks[21];
+} int672m_T;
+
+typedef struct {
+  int672m_T re;
+  int672m_T im;
+} cint672m_T;
+
+typedef struct {
+  uint32_T chunks[21];
+} uint672m_T;
+
+typedef struct {
+  uint672m_T re;
+  uint672m_T im;
+} cuint672m_T;
+
+typedef struct {
+  uint32_T chunks[22];
+} int704m_T;
+
+typedef struct {
+  int704m_T re;
+  int704m_T im;
+} cint704m_T;
+
+typedef struct {
+  uint32_T chunks[22];
+} uint704m_T;
+
+typedef struct {
+  uint704m_T re;
+  uint704m_T im;
+} cuint704m_T;
+
+typedef struct {
+  uint32_T chunks[23];
+} int736m_T;
+
+typedef struct {
+  int736m_T re;
+  int736m_T im;
+} cint736m_T;
+
+typedef struct {
+  uint32_T chunks[23];
+} uint736m_T;
+
+typedef struct {
+  uint736m_T re;
+  uint736m_T im;
+} cuint736m_T;
+
+typedef struct {
+  uint32_T chunks[24];
+} int768m_T;
+
+typedef struct {
+  int768m_T re;
+  int768m_T im;
+} cint768m_T;
+
+typedef struct {
+  uint32_T chunks[24];
+} uint768m_T;
+
+typedef struct {
+  uint768m_T re;
+  uint768m_T im;
+} cuint768m_T;
+
+typedef struct {
+  uint32_T chunks[25];
+} int800m_T;
+
+typedef struct {
+  int800m_T re;
+  int800m_T im;
+} cint800m_T;
+
+typedef struct {
+  uint32_T chunks[25];
+} uint800m_T;
+
+typedef struct {
+  uint800m_T re;
+  uint800m_T im;
+} cuint800m_T;
+
+typedef struct {
+  uint32_T chunks[26];
+} int832m_T;
+
+typedef struct {
+  int832m_T re;
+  int832m_T im;
+} cint832m_T;
+
+typedef struct {
+  uint32_T chunks[26];
+} uint832m_T;
+
+typedef struct {
+  uint832m_T re;
+  uint832m_T im;
+} cuint832m_T;
+
+typedef struct {
+  uint32_T chunks[27];
+} int864m_T;
+
+typedef struct {
+  int864m_T re;
+  int864m_T im;
+} cint864m_T;
+
+typedef struct {
+  uint32_T chunks[27];
+} uint864m_T;
+
+typedef struct {
+  uint864m_T re;
+  uint864m_T im;
+} cuint864m_T;
+
+typedef struct {
+  uint32_T chunks[28];
+} int896m_T;
+
+typedef struct {
+  int896m_T re;
+  int896m_T im;
+} cint896m_T;
+
+typedef struct {
+  uint32_T chunks[28];
+} uint896m_T;
+
+typedef struct {
+  uint896m_T re;
+  uint896m_T im;
+} cuint896m_T;
+
+typedef struct {
+  uint32_T chunks[29];
+} int928m_T;
+
+typedef struct {
+  int928m_T re;
+  int928m_T im;
+} cint928m_T;
+
+typedef struct {
+  uint32_T chunks[29];
+} uint928m_T;
+
+typedef struct {
+  uint928m_T re;
+  uint928m_T im;
+} cuint928m_T;
+
+typedef struct {
+  uint32_T chunks[30];
+} int960m_T;
+
+typedef struct {
+  int960m_T re;
+  int960m_T im;
+} cint960m_T;
+
+typedef struct {
+  uint32_T chunks[30];
+} uint960m_T;
+
+typedef struct {
+  uint960m_T re;
+  uint960m_T im;
+} cuint960m_T;
+
+typedef struct {
+  uint32_T chunks[31];
+} int992m_T;
+
+typedef struct {
+  int992m_T re;
+  int992m_T im;
+} cint992m_T;
+
+typedef struct {
+  uint32_T chunks[31];
+} uint992m_T;
+
+typedef struct {
+  uint992m_T re;
+  uint992m_T im;
+} cuint992m_T;
+
+typedef struct {
+  uint32_T chunks[32];
+} int1024m_T;
+
+typedef struct {
+  int1024m_T re;
+  int1024m_T im;
+} cint1024m_T;
+
+typedef struct {
+  uint32_T chunks[32];
+} uint1024m_T;
+
+typedef struct {
+  uint1024m_T re;
+  uint1024m_T im;
+} cuint1024m_T;
+
+typedef struct {
+  uint32_T chunks[33];
+} int1056m_T;
+
+typedef struct {
+  int1056m_T re;
+  int1056m_T im;
+} cint1056m_T;
+
+typedef struct {
+  uint32_T chunks[33];
+} uint1056m_T;
+
+typedef struct {
+  uint1056m_T re;
+  uint1056m_T im;
+} cuint1056m_T;
+
+typedef struct {
+  uint32_T chunks[34];
+} int1088m_T;
+
+typedef struct {
+  int1088m_T re;
+  int1088m_T im;
+} cint1088m_T;
+
+typedef struct {
+  uint32_T chunks[34];
+} uint1088m_T;
+
+typedef struct {
+  uint1088m_T re;
+  uint1088m_T im;
+} cuint1088m_T;
+
+typedef struct {
+  uint32_T chunks[35];
+} int1120m_T;
+
+typedef struct {
+  int1120m_T re;
+  int1120m_T im;
+} cint1120m_T;
+
+typedef struct {
+  uint32_T chunks[35];
+} uint1120m_T;
+
+typedef struct {
+  uint1120m_T re;
+  uint1120m_T im;
+} cuint1120m_T;
+
+typedef struct {
+  uint32_T chunks[36];
+} int1152m_T;
+
+typedef struct {
+  int1152m_T re;
+  int1152m_T im;
+} cint1152m_T;
+
+typedef struct {
+  uint32_T chunks[36];
+} uint1152m_T;
+
+typedef struct {
+  uint1152m_T re;
+  uint1152m_T im;
+} cuint1152m_T;
+
+typedef struct {
+  uint32_T chunks[37];
+} int1184m_T;
+
+typedef struct {
+  int1184m_T re;
+  int1184m_T im;
+} cint1184m_T;
+
+typedef struct {
+  uint32_T chunks[37];
+} uint1184m_T;
+
+typedef struct {
+  uint1184m_T re;
+  uint1184m_T im;
+} cuint1184m_T;
+
+typedef struct {
+  uint32_T chunks[38];
+} int1216m_T;
+
+typedef struct {
+  int1216m_T re;
+  int1216m_T im;
+} cint1216m_T;
+
+typedef struct {
+  uint32_T chunks[38];
+} uint1216m_T;
+
+typedef struct {
+  uint1216m_T re;
+  uint1216m_T im;
+} cuint1216m_T;
+
+typedef struct {
+  uint32_T chunks[39];
+} int1248m_T;
+
+typedef struct {
+  int1248m_T re;
+  int1248m_T im;
+} cint1248m_T;
+
+typedef struct {
+  uint32_T chunks[39];
+} uint1248m_T;
+
+typedef struct {
+  uint1248m_T re;
+  uint1248m_T im;
+} cuint1248m_T;
+
+typedef struct {
+  uint32_T chunks[40];
+} int1280m_T;
+
+typedef struct {
+  int1280m_T re;
+  int1280m_T im;
+} cint1280m_T;
+
+typedef struct {
+  uint32_T chunks[40];
+} uint1280m_T;
+
+typedef struct {
+  uint1280m_T re;
+  uint1280m_T im;
+} cuint1280m_T;
+
+typedef struct {
+  uint32_T chunks[41];
+} int1312m_T;
+
+typedef struct {
+  int1312m_T re;
+  int1312m_T im;
+} cint1312m_T;
+
+typedef struct {
+  uint32_T chunks[41];
+} uint1312m_T;
+
+typedef struct {
+  uint1312m_T re;
+  uint1312m_T im;
+} cuint1312m_T;
+
+typedef struct {
+  uint32_T chunks[42];
+} int1344m_T;
+
+typedef struct {
+  int1344m_T re;
+  int1344m_T im;
+} cint1344m_T;
+
+typedef struct {
+  uint32_T chunks[42];
+} uint1344m_T;
+
+typedef struct {
+  uint1344m_T re;
+  uint1344m_T im;
+} cuint1344m_T;
+
+typedef struct {
+  uint32_T chunks[43];
+} int1376m_T;
+
+typedef struct {
+  int1376m_T re;
+  int1376m_T im;
+} cint1376m_T;
+
+typedef struct {
+  uint32_T chunks[43];
+} uint1376m_T;
+
+typedef struct {
+  uint1376m_T re;
+  uint1376m_T im;
+} cuint1376m_T;
+
+typedef struct {
+  uint32_T chunks[44];
+} int1408m_T;
+
+typedef struct {
+  int1408m_T re;
+  int1408m_T im;
+} cint1408m_T;
+
+typedef struct {
+  uint32_T chunks[44];
+} uint1408m_T;
+
+typedef struct {
+  uint1408m_T re;
+  uint1408m_T im;
+} cuint1408m_T;
+
+typedef struct {
+  uint32_T chunks[45];
+} int1440m_T;
+
+typedef struct {
+  int1440m_T re;
+  int1440m_T im;
+} cint1440m_T;
+
+typedef struct {
+  uint32_T chunks[45];
+} uint1440m_T;
+
+typedef struct {
+  uint1440m_T re;
+  uint1440m_T im;
+} cuint1440m_T;
+
+typedef struct {
+  uint32_T chunks[46];
+} int1472m_T;
+
+typedef struct {
+  int1472m_T re;
+  int1472m_T im;
+} cint1472m_T;
+
+typedef struct {
+  uint32_T chunks[46];
+} uint1472m_T;
+
+typedef struct {
+  uint1472m_T re;
+  uint1472m_T im;
+} cuint1472m_T;
+
+typedef struct {
+  uint32_T chunks[47];
+} int1504m_T;
+
+typedef struct {
+  int1504m_T re;
+  int1504m_T im;
+} cint1504m_T;
+
+typedef struct {
+  uint32_T chunks[47];
+} uint1504m_T;
+
+typedef struct {
+  uint1504m_T re;
+  uint1504m_T im;
+} cuint1504m_T;
+
+typedef struct {
+  uint32_T chunks[48];
+} int1536m_T;
+
+typedef struct {
+  int1536m_T re;
+  int1536m_T im;
+} cint1536m_T;
+
+typedef struct {
+  uint32_T chunks[48];
+} uint1536m_T;
+
+typedef struct {
+  uint1536m_T re;
+  uint1536m_T im;
+} cuint1536m_T;
+
+typedef struct {
+  uint32_T chunks[49];
+} int1568m_T;
+
+typedef struct {
+  int1568m_T re;
+  int1568m_T im;
+} cint1568m_T;
+
+typedef struct {
+  uint32_T chunks[49];
+} uint1568m_T;
+
+typedef struct {
+  uint1568m_T re;
+  uint1568m_T im;
+} cuint1568m_T;
+
+typedef struct {
+  uint32_T chunks[50];
+} int1600m_T;
+
+typedef struct {
+  int1600m_T re;
+  int1600m_T im;
+} cint1600m_T;
+
+typedef struct {
+  uint32_T chunks[50];
+} uint1600m_T;
+
+typedef struct {
+  uint1600m_T re;
+  uint1600m_T im;
+} cuint1600m_T;
+
+typedef struct {
+  uint32_T chunks[51];
+} int1632m_T;
+
+typedef struct {
+  int1632m_T re;
+  int1632m_T im;
+} cint1632m_T;
+
+typedef struct {
+  uint32_T chunks[51];
+} uint1632m_T;
+
+typedef struct {
+  uint1632m_T re;
+  uint1632m_T im;
+} cuint1632m_T;
+
+typedef struct {
+  uint32_T chunks[52];
+} int1664m_T;
+
+typedef struct {
+  int1664m_T re;
+  int1664m_T im;
+} cint1664m_T;
+
+typedef struct {
+  uint32_T chunks[52];
+} uint1664m_T;
+
+typedef struct {
+  uint1664m_T re;
+  uint1664m_T im;
+} cuint1664m_T;
+
+typedef struct {
+  uint32_T chunks[53];
+} int1696m_T;
+
+typedef struct {
+  int1696m_T re;
+  int1696m_T im;
+} cint1696m_T;
+
+typedef struct {
+  uint32_T chunks[53];
+} uint1696m_T;
+
+typedef struct {
+  uint1696m_T re;
+  uint1696m_T im;
+} cuint1696m_T;
+
+typedef struct {
+  uint32_T chunks[54];
+} int1728m_T;
+
+typedef struct {
+  int1728m_T re;
+  int1728m_T im;
+} cint1728m_T;
+
+typedef struct {
+  uint32_T chunks[54];
+} uint1728m_T;
+
+typedef struct {
+  uint1728m_T re;
+  uint1728m_T im;
+} cuint1728m_T;
+
+typedef struct {
+  uint32_T chunks[55];
+} int1760m_T;
+
+typedef struct {
+  int1760m_T re;
+  int1760m_T im;
+} cint1760m_T;
+
+typedef struct {
+  uint32_T chunks[55];
+} uint1760m_T;
+
+typedef struct {
+  uint1760m_T re;
+  uint1760m_T im;
+} cuint1760m_T;
+
+typedef struct {
+  uint32_T chunks[56];
+} int1792m_T;
+
+typedef struct {
+  int1792m_T re;
+  int1792m_T im;
+} cint1792m_T;
+
+typedef struct {
+  uint32_T chunks[56];
+} uint1792m_T;
+
+typedef struct {
+  uint1792m_T re;
+  uint1792m_T im;
+} cuint1792m_T;
+
+typedef struct {
+  uint32_T chunks[57];
+} int1824m_T;
+
+typedef struct {
+  int1824m_T re;
+  int1824m_T im;
+} cint1824m_T;
+
+typedef struct {
+  uint32_T chunks[57];
+} uint1824m_T;
+
+typedef struct {
+  uint1824m_T re;
+  uint1824m_T im;
+} cuint1824m_T;
+
+typedef struct {
+  uint32_T chunks[58];
+} int1856m_T;
+
+typedef struct {
+  int1856m_T re;
+  int1856m_T im;
+} cint1856m_T;
+
+typedef struct {
+  uint32_T chunks[58];
+} uint1856m_T;
+
+typedef struct {
+  uint1856m_T re;
+  uint1856m_T im;
+} cuint1856m_T;
+
+typedef struct {
+  uint32_T chunks[59];
+} int1888m_T;
+
+typedef struct {
+  int1888m_T re;
+  int1888m_T im;
+} cint1888m_T;
+
+typedef struct {
+  uint32_T chunks[59];
+} uint1888m_T;
+
+typedef struct {
+  uint1888m_T re;
+  uint1888m_T im;
+} cuint1888m_T;
+
+typedef struct {
+  uint32_T chunks[60];
+} int1920m_T;
+
+typedef struct {
+  int1920m_T re;
+  int1920m_T im;
+} cint1920m_T;
+
+typedef struct {
+  uint32_T chunks[60];
+} uint1920m_T;
+
+typedef struct {
+  uint1920m_T re;
+  uint1920m_T im;
+} cuint1920m_T;
+
+typedef struct {
+  uint32_T chunks[61];
+} int1952m_T;
+
+typedef struct {
+  int1952m_T re;
+  int1952m_T im;
+} cint1952m_T;
+
+typedef struct {
+  uint32_T chunks[61];
+} uint1952m_T;
+
+typedef struct {
+  uint1952m_T re;
+  uint1952m_T im;
+} cuint1952m_T;
+
+typedef struct {
+  uint32_T chunks[62];
+} int1984m_T;
+
+typedef struct {
+  int1984m_T re;
+  int1984m_T im;
+} cint1984m_T;
+
+typedef struct {
+  uint32_T chunks[62];
+} uint1984m_T;
+
+typedef struct {
+  uint1984m_T re;
+  uint1984m_T im;
+} cuint1984m_T;
+
+typedef struct {
+  uint32_T chunks[63];
+} int2016m_T;
+
+typedef struct {
+  int2016m_T re;
+  int2016m_T im;
+} cint2016m_T;
+
+typedef struct {
+  uint32_T chunks[63];
+} uint2016m_T;
+
+typedef struct {
+  uint2016m_T re;
+  uint2016m_T im;
+} cuint2016m_T;
+
+typedef struct {
+  uint32_T chunks[64];
+} int2048m_T;
+
+typedef struct {
+  int2048m_T re;
+  int2048m_T im;
+} cint2048m_T;
+
+typedef struct {
+  uint32_T chunks[64];
+} uint2048m_T;
+
+typedef struct {
+  uint2048m_T re;
+  uint2048m_T im;
+} cuint2048m_T;
+
+#endif                                 /* MULTIWORD_TYPES_H */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h
new file mode 100644
index 000000000..10431a4cc
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtmodel.h
@@ -0,0 +1,39 @@
+/*
+ *  rtmodel.h:
+ *
+ * Academic License - for use in teaching, academic research, and meeting
+ * course requirements at degree granting institutions only.  Not for
+ * government, commercial, or other organizational use.
+ *
+ * Code generation for model "run_ADA".
+ *
+ * Model version              : 1.25
+ * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022
+ * C++ source code generated on : Wed Oct 25 17:58:39 2023
+ *
+ * Target selection: grt.tlc
+ * Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: Intel->x86-64 (Windows64)
+ * Code generation objective: Execution efficiency
+ * Validation result: Not run
+ */
+
+#ifndef RTW_HEADER_rtmodel_h_
+#define RTW_HEADER_rtmodel_h_
+#include "run_ADA.h"
+#define MODEL_CLASSNAME                run_ADA
+#define MODEL_STEPNAME                 step
+#define GRTINTERFACE                   0
+
+/*
+ * ROOT_IO_FORMAT: 0 (Individual arguments)
+ * ROOT_IO_FORMAT: 1 (Structure reference)
+ * ROOT_IO_FORMAT: 2 (Part of model data structure)
+ */
+#define ROOT_IO_FORMAT                 2
+
+/* Macros generated for backwards compatibility  */
+#ifndef rtmGetStopRequested
+#define rtmGetStopRequested(rtm)       ((void*) 0)
+#endif
+#endif                                 /* RTW_HEADER_rtmodel_h_ */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h
new file mode 100644
index 000000000..1ffac7ee7
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/rtwtypes.h
@@ -0,0 +1,41 @@
+/*
+ * rtwtypes.h
+ *
+ * Academic License - for use in teaching, academic research, and meeting
+ * course requirements at degree granting institutions only.  Not for
+ * government, commercial, or other organizational use.
+ *
+ * Code generation for model "run_ADA".
+ *
+ * Model version              : 1.25
+ * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022
+ * C++ source code generated on : Wed Oct 25 17:58:39 2023
+ *
+ * Target selection: grt.tlc
+ * Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: Intel->x86-64 (Windows64)
+ * Code generation objective: Execution efficiency
+ * Validation result: Not run
+ */
+
+#ifndef RTWTYPES_H
+#define RTWTYPES_H
+#include "tmwtypes.h"
+#ifndef POINTER_T
+#define POINTER_T
+
+typedef void * pointer_T;
+
+#endif
+
+/* Logical type definitions */
+#if (!defined(__cplusplus))
+#ifndef false
+#define false                          (0U)
+#endif
+
+#ifndef true
+#define true                           (1U)
+#endif
+#endif
+#endif                                 /* RTWTYPES_H */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp
new file mode 100644
index 000000000..79e57b2fa
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.cpp
@@ -0,0 +1,347 @@
+/*
+ * run_ADA.cpp
+ *
+ * Academic License - for use in teaching, academic research, and meeting
+ * course requirements at degree granting institutions only.  Not for
+ * government, commercial, or other organizational use.
+ *
+ * Code generation for model "run_ADA".
+ *
+ * Model version              : 1.25
+ * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022
+ * C++ source code generated on : Wed Oct 25 17:58:39 2023
+ *
+ * Target selection: grt.tlc
+ * Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: Intel->x86-64 (Windows64)
+ * Code generation objective: Execution efficiency
+ * Validation result: Not run
+ */
+
+#include "run_ADA.h"
+#include "rtwtypes.h"
+#include <cstring>
+#include <cmath>
+#include <emmintrin.h>
+
+/* System initialize for atomic system: '<Root>/run_ADA' */
+void run_ADA::run_ADA_run_ADA_Init(DW_run_ADA_run_ADA_T *localDW)
+{
+  /* InitializeConditions for Memory: '<S1>/H_memory' */
+  localDW->H_memory_PreviousInput[0] = 1.0;
+  localDW->H_memory_PreviousInput[1] = 0.0;
+  localDW->H_memory_PreviousInput[2] = 0.0;
+
+  /* InitializeConditions for Memory: '<S1>/F_memory' */
+  std::memcpy(&localDW->F_memory_PreviousInput[0],
+              &run_ADA_ConstP.F_memory_InitialCondition[0], 9U * sizeof(real_T));
+
+  /* InitializeConditions for Memory: '<S1>/P_memory' */
+  std::memcpy(&localDW->P_memory_PreviousInput[0], &run_ADA_ConstP.pooled5[0],
+              9U * sizeof(real_T));
+
+  /* InitializeConditions for Memory: '<S1>/Q_memory' */
+  std::memcpy(&localDW->Q_memory_PreviousInput[0],
+              &run_ADA_ConstP.Q_memory_InitialCondition[0], 9U * sizeof(real_T));
+
+  /* InitializeConditions for Memory: '<S1>/H_memory1' */
+  localDW->H_memory1_PreviousInput = 4000.0;
+
+  /* InitializeConditions for Memory: '<S1>/x_memory' */
+  localDW->x_memory_PreviousInput[0] = 0.0;
+  localDW->x_memory_PreviousInput[1] = 0.0;
+  localDW->x_memory_PreviousInput[2] = 1.0;
+}
+
+/* Output and update for atomic system: '<Root>/run_ADA' */
+void run_ADA::run_ADA_run_ADA(real_T rtu_Pressure, B_run_ADA_run_ADA_T *localB,
+  DW_run_ADA_run_ADA_T *localDW) const
+{
+  __m128d tmp_0;
+  __m128d tmp_1;
+  __m128d tmp_2;
+  real_T rtb_Add[9];
+  real_T tmp[9];
+  real_T rtb_K[3];
+  real_T rtb_MatrixMultiply[3];
+  real_T F_memory_PreviousInput;
+  real_T F_memory_PreviousInput_0;
+  real_T F_memory_PreviousInput_1;
+  real_T P_memory_PreviousInput;
+  real_T P_memory_PreviousInput_0;
+  real_T rtb_MatrixMultiply_0;
+  real_T rtb_Product_n;
+  real_T x_memory_PreviousInput;
+  int32_T i;
+  int32_T i_0;
+  int32_T rtb_Add_tmp;
+
+  /* Product: '<S3>/Matrix Multiply1' incorporates:
+   *  Math: '<S3>/Transpose'
+   *  Memory: '<S1>/F_memory'
+   *  Memory: '<S1>/P_memory'
+   */
+  for (i_0 = 0; i_0 < 3; i_0++) {
+    rtb_Product_n = localDW->P_memory_PreviousInput[i_0 + 3];
+    P_memory_PreviousInput = localDW->P_memory_PreviousInput[i_0];
+    P_memory_PreviousInput_0 = localDW->P_memory_PreviousInput[i_0 + 6];
+    for (i = 0; i < 3; i++) {
+      tmp[i_0 + 3 * i] = (localDW->F_memory_PreviousInput[i + 3] * rtb_Product_n
+                          + P_memory_PreviousInput *
+                          localDW->F_memory_PreviousInput[i]) +
+        localDW->F_memory_PreviousInput[i + 6] * P_memory_PreviousInput_0;
+    }
+  }
+
+  /* Product: '<S2>/Matrix Multiply' */
+  rtb_Product_n = 0.0;
+  for (i_0 = 0; i_0 < 3; i_0++) {
+    /* Sum: '<S3>/Add' incorporates:
+     *  Memory: '<S1>/F_memory'
+     *  Product: '<S3>/Matrix Multiply1'
+     */
+    F_memory_PreviousInput = localDW->F_memory_PreviousInput[i_0 + 3];
+    F_memory_PreviousInput_0 = localDW->F_memory_PreviousInput[i_0];
+    F_memory_PreviousInput_1 = localDW->F_memory_PreviousInput[i_0 + 6];
+
+    /* Product: '<S2>/Matrix Multiply' */
+    P_memory_PreviousInput = 0.0;
+    for (i = 0; i < 3; i++) {
+      /* Sum: '<S3>/Add' incorporates:
+       *  Memory: '<S1>/Q_memory'
+       *  Product: '<S3>/Matrix Multiply1'
+       */
+      rtb_Add_tmp = 3 * i + i_0;
+      P_memory_PreviousInput_0 = ((tmp[3 * i + 1] * F_memory_PreviousInput +
+        tmp[3 * i] * F_memory_PreviousInput_0) + tmp[3 * i + 2] *
+        F_memory_PreviousInput_1) + localDW->Q_memory_PreviousInput[rtb_Add_tmp];
+      rtb_Add[rtb_Add_tmp] = P_memory_PreviousInput_0;
+
+      /* Product: '<S2>/Matrix Multiply' incorporates:
+       *  Memory: '<S1>/H_memory'
+       */
+      P_memory_PreviousInput += P_memory_PreviousInput_0 *
+        localDW->H_memory_PreviousInput[i];
+    }
+
+    /* Product: '<S2>/Matrix Multiply' incorporates:
+     *  Memory: '<S1>/H_memory'
+     */
+    rtb_Product_n += localDW->H_memory_PreviousInput[i_0] *
+      P_memory_PreviousInput;
+  }
+
+  /* Sum: '<S2>/Add' incorporates:
+   *  Memory: '<S1>/H_memory1'
+   *  Product: '<S2>/Matrix Multiply'
+   */
+  rtb_Product_n += localDW->H_memory1_PreviousInput;
+
+  /* Product: '<S2>/Matrix Multiply1' incorporates:
+   *  Memory: '<S1>/H_memory'
+   */
+  P_memory_PreviousInput = localDW->H_memory_PreviousInput[0] / rtb_Product_n;
+  P_memory_PreviousInput_0 = localDW->H_memory_PreviousInput[1] / rtb_Product_n;
+  F_memory_PreviousInput = localDW->H_memory_PreviousInput[2] / rtb_Product_n;
+
+  /* Product: '<S2>/Matrix Multiply4' */
+  rtb_Product_n = 0.0;
+
+  /* Memory: '<S1>/x_memory' incorporates:
+   *  Product: '<S3>/Matrix Multiply'
+   */
+  F_memory_PreviousInput_0 = localDW->x_memory_PreviousInput[1];
+  F_memory_PreviousInput_1 = localDW->x_memory_PreviousInput[0];
+  x_memory_PreviousInput = localDW->x_memory_PreviousInput[2];
+  for (i_0 = 0; i_0 < 3; i_0++) {
+    /* Product: '<S3>/Matrix Multiply' incorporates:
+     *  Memory: '<S1>/F_memory'
+     *  Memory: '<S1>/x_memory'
+     */
+    rtb_MatrixMultiply_0 = (localDW->F_memory_PreviousInput[i_0 + 3] *
+      F_memory_PreviousInput_0 + localDW->F_memory_PreviousInput[i_0] *
+      F_memory_PreviousInput_1) + localDW->F_memory_PreviousInput[i_0 + 6] *
+      x_memory_PreviousInput;
+    rtb_MatrixMultiply[i_0] = rtb_MatrixMultiply_0;
+
+    /* Product: '<S2>/Matrix Multiply1' incorporates:
+     *  Sum: '<S3>/Add'
+     */
+    rtb_K[i_0] = (rtb_Add[i_0 + 3] * P_memory_PreviousInput_0 + rtb_Add[i_0] *
+                  P_memory_PreviousInput) + rtb_Add[i_0 + 6] *
+      F_memory_PreviousInput;
+
+    /* Product: '<S2>/Matrix Multiply4' incorporates:
+     *  Memory: '<S1>/H_memory'
+     *  Product: '<S3>/Matrix Multiply'
+     */
+    rtb_Product_n += localDW->H_memory_PreviousInput[i_0] * rtb_MatrixMultiply_0;
+  }
+
+  /* Sum: '<S2>/Subtract' incorporates:
+   *  Product: '<S2>/Matrix Multiply4'
+   */
+  rtb_Product_n = rtu_Pressure - rtb_Product_n;
+
+  /* DigitalClock: '<S1>/Digital Clock' */
+  localB->BusCreator.timestamp = ((((&run_ADA_M)->Timing.clockTick0+(&run_ADA_M
+    )->Timing.clockTickH0* 4294967296.0)) * 0.02);
+  for (i = 0; i < 3; i++) {
+    /* Sum: '<S2>/Add2' incorporates:
+     *  Product: '<S2>/Matrix Multiply1'
+     *  Product: '<S2>/Matrix Multiply5'
+     *  Product: '<S3>/Matrix Multiply'
+     */
+    localDW->x_memory_PreviousInput[i] = rtb_K[i] * rtb_Product_n +
+      rtb_MatrixMultiply[i];
+
+    /* Memory: '<S1>/H_memory' incorporates:
+     *  Product: '<S2>/Matrix Multiply2'
+     */
+    P_memory_PreviousInput = localDW->H_memory_PreviousInput[i];
+
+    /* Sum: '<S2>/Add1' incorporates:
+     *  Constant: '<S2>/I'
+     *  Memory: '<S1>/H_memory'
+     *  Product: '<S2>/Matrix Multiply1'
+     *  Product: '<S2>/Matrix Multiply2'
+     */
+    tmp[3 * i] = run_ADA_ConstP.pooled5[3 * i] - rtb_K[0] *
+      P_memory_PreviousInput;
+    i_0 = 3 * i + 1;
+    tmp[i_0] = run_ADA_ConstP.pooled5[i_0] - rtb_K[1] * P_memory_PreviousInput;
+    i_0 = 3 * i + 2;
+    tmp[i_0] = run_ADA_ConstP.pooled5[i_0] - rtb_K[2] * P_memory_PreviousInput;
+  }
+
+  /* Math: '<S4>/Pow' incorporates:
+   *  Constant: '<S4>/P_ref'
+   *  Math: '<S5>/Pow'
+   *  Product: '<S4>/Divide1'
+   */
+  P_memory_PreviousInput = std::pow(localDW->x_memory_PreviousInput[0] /
+    101325.0, 0.19025441011522382);
+
+  /* Product: '<S4>/Product' incorporates:
+   *  Constant: '<S4>/Constant'
+   *  Math: '<S4>/Pow'
+   *  Sum: '<S4>/Subtract'
+   */
+  rtb_Product_n = (1.0 - P_memory_PreviousInput) * 44330.769230769227;
+
+  /* Sum: '<S1>/Subtract' incorporates:
+   *  Constant: '<S1>/Constant'
+   */
+  localB->BusCreator.aglAltitude = rtb_Product_n - 160.0;
+
+  /* BusCreator: '<S1>/Bus Creator' incorporates:
+   *  Constant: '<S5>/Constant1'
+   *  Constant: '<S5>/T_ref'
+   *  Constant: '<S5>/a'
+   *  Gain: '<S5>/Gain'
+   *  Product: '<S5>/Divide'
+   *  Product: '<S5>/Product'
+   *  Product: '<S5>/Product1'
+   */
+  localB->BusCreator.mslAltitude = rtb_Product_n;
+  localB->BusCreator.verticalSpeed = -(1.0 / (0.0012366536657489548 *
+    localDW->x_memory_PreviousInput[0]) * (288.15 *
+    localDW->x_memory_PreviousInput[1] * P_memory_PreviousInput));
+  localB->BusCreator.x0 = localDW->x_memory_PreviousInput[0];
+  localB->BusCreator.x1 = localDW->x_memory_PreviousInput[1];
+  localB->BusCreator.x2 = localDW->x_memory_PreviousInput[2];
+
+  /* Update for Memory: '<S1>/P_memory' incorporates:
+   *  Product: '<S2>/Matrix Multiply3'
+   */
+  for (i_0 = 0; i_0 < 3; i_0++) {
+    /* Product: '<S2>/Matrix Multiply3' incorporates:
+     *  Sum: '<S3>/Add'
+     */
+    P_memory_PreviousInput = rtb_Add[3 * i_0 + 1];
+    P_memory_PreviousInput_0 = rtb_Add[3 * i_0];
+    rtb_Product_n = rtb_Add[3 * i_0 + 2];
+    for (i = 0; i <= 0; i += 2) {
+      tmp_0 = _mm_loadu_pd(&tmp[i + 3]);
+      tmp_1 = _mm_loadu_pd(&tmp[i]);
+      tmp_2 = _mm_loadu_pd(&tmp[i + 6]);
+      _mm_storeu_pd(&localDW->P_memory_PreviousInput[i + 3 * i_0], _mm_add_pd
+                    (_mm_add_pd(_mm_mul_pd(_mm_set1_pd(P_memory_PreviousInput),
+        tmp_0), _mm_mul_pd(_mm_set1_pd(P_memory_PreviousInput_0), tmp_1)),
+                     _mm_mul_pd(_mm_set1_pd(rtb_Product_n), tmp_2)));
+    }
+
+    for (i = 2; i < 3; i++) {
+      localDW->P_memory_PreviousInput[i + 3 * i_0] = (tmp[i + 3] *
+        P_memory_PreviousInput + P_memory_PreviousInput_0 * tmp[i]) + tmp[i + 6]
+        * rtb_Product_n;
+    }
+  }
+
+  /* End of Update for Memory: '<S1>/P_memory' */
+}
+
+/* Model step function */
+void run_ADA::step()
+{
+  /* Outputs for Atomic SubSystem: '<Root>/run_ADA' */
+
+  /* Inport: '<Root>/Pressure' */
+  run_ADA_run_ADA(run_ADA_U.Pressure, &run_ADA_B.run_ADA_e,
+                  &run_ADA_DW.run_ADA_e);
+
+  /* End of Outputs for SubSystem: '<Root>/run_ADA' */
+
+  /* Outport: '<Root>/ADAState' */
+  run_ADA_Y.ADAState_o = run_ADA_B.run_ADA_e.BusCreator;
+
+  /* Update absolute time for base rate */
+  /* The "clockTick0" counts the number of times the code of this task has
+   * been executed. The resolution of this integer timer is 0.02, which is the step size
+   * of the task. 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.
+   */
+  (&run_ADA_M)->Timing.clockTick0++;
+  if (!(&run_ADA_M)->Timing.clockTick0) {
+    (&run_ADA_M)->Timing.clockTickH0++;
+  }
+}
+
+/* Model initialize function */
+void run_ADA::initialize()
+{
+  /* SystemInitialize for Atomic SubSystem: '<Root>/run_ADA' */
+  run_ADA_run_ADA_Init(&run_ADA_DW.run_ADA_e);
+
+  /* End of SystemInitialize for SubSystem: '<Root>/run_ADA' */
+}
+
+/* Model terminate function */
+void run_ADA::terminate()
+{
+  /* (no terminate code required) */
+}
+
+/* Constructor */
+run_ADA::run_ADA() :
+  run_ADA_U(),
+  run_ADA_Y(),
+  run_ADA_B(),
+  run_ADA_DW(),
+  run_ADA_M()
+{
+  /* Currently there is no constructor body generated.*/
+}
+
+/* Destructor */
+/* Currently there is no destructor body generated.*/
+run_ADA::~run_ADA() = default;
+
+/* Real-Time Model get method */
+RT_MODEL_run_ADA_T * run_ADA::getRTM()
+{
+  return (&run_ADA_M);
+}
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h
new file mode 100644
index 000000000..a8c397ba8
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA.h
@@ -0,0 +1,212 @@
+/*
+ * run_ADA.h
+ *
+ * Academic License - for use in teaching, academic research, and meeting
+ * course requirements at degree granting institutions only.  Not for
+ * government, commercial, or other organizational use.
+ *
+ * Code generation for model "run_ADA".
+ *
+ * Model version              : 1.25
+ * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022
+ * C++ source code generated on : Wed Oct 25 17:58:39 2023
+ *
+ * Target selection: grt.tlc
+ * Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: Intel->x86-64 (Windows64)
+ * Code generation objective: Execution efficiency
+ * Validation result: Not run
+ */
+
+#ifndef RTW_HEADER_run_ADA_h_
+#define RTW_HEADER_run_ADA_h_
+#include "rtwtypes.h"
+#include "rtw_continuous.h"
+#include "rtw_solver.h"
+#include "run_ADA_types.h"
+
+/* Macros for accessing real-time model data structure */
+#ifndef rtmGetErrorStatus
+#define rtmGetErrorStatus(rtm)         ((rtm)->errorStatus)
+#endif
+
+#ifndef rtmSetErrorStatus
+#define rtmSetErrorStatus(rtm, val)    ((rtm)->errorStatus = (val))
+#endif
+
+/* Block signals for system '<Root>/run_ADA' */
+struct B_run_ADA_run_ADA_T {
+  ADAState BusCreator;                 /* '<S1>/Bus Creator' */
+};
+
+/* Block states (default storage) for system '<Root>/run_ADA' */
+struct DW_run_ADA_run_ADA_T {
+  real_T H_memory_PreviousInput[3];    /* '<S1>/H_memory' */
+  real_T F_memory_PreviousInput[9];    /* '<S1>/F_memory' */
+  real_T P_memory_PreviousInput[9];    /* '<S1>/P_memory' */
+  real_T Q_memory_PreviousInput[9];    /* '<S1>/Q_memory' */
+  real_T H_memory1_PreviousInput;      /* '<S1>/H_memory1' */
+  real_T MatrixMultiply1_DWORK4;       /* '<S2>/Matrix Multiply1' */
+  real_T x_memory_PreviousInput[3];    /* '<S1>/x_memory' */
+};
+
+/* Block signals (default storage) */
+struct B_run_ADA_T {
+  B_run_ADA_run_ADA_T run_ADA_e;       /* '<Root>/run_ADA' */
+};
+
+/* Block states (default storage) for system '<Root>' */
+struct DW_run_ADA_T {
+  DW_run_ADA_run_ADA_T run_ADA_e;      /* '<Root>/run_ADA' */
+};
+
+/* Constant parameters (default storage) */
+struct ConstP_run_ADA_T {
+  /* Expression: [1 0.02 0.5*0.02^2; 0 1 0.02; 0 0 1]
+   * Referenced by: '<S1>/F_memory'
+   */
+  real_T F_memory_InitialCondition[9];
+
+  /* Pooled Parameter (Expression: eye(3))
+   * Referenced by:
+   *   '<S1>/P_memory'
+   *   '<S2>/I'
+   */
+  real_T pooled5[9];
+
+  /* Expression: [30 0 0; 0 10 0; 0 0 2.5]
+   * Referenced by: '<S1>/Q_memory'
+   */
+  real_T Q_memory_InitialCondition[9];
+};
+
+/* External inputs (root inport signals with default storage) */
+struct ExtU_run_ADA_T {
+  real_T Pressure;                     /* '<Root>/Pressure' */
+};
+
+/* External outputs (root outports fed by signals with default storage) */
+struct ExtY_run_ADA_T {
+  ADAState ADAState_o;                 /* '<Root>/ADAState' */
+};
+
+/* Real-time Model Data Structure */
+struct tag_RTM_run_ADA_T {
+  const char_T *errorStatus;
+
+  /*
+   * Timing:
+   * The following substructure contains information regarding
+   * the timing information for the model.
+   */
+  struct {
+    uint32_T clockTick0;
+    uint32_T clockTickH0;
+  } Timing;
+};
+
+/* Constant parameters (default storage) */
+extern const ConstP_run_ADA_T run_ADA_ConstP;
+
+/* Class declaration for model run_ADA */
+class run_ADA final
+{
+  /* public data and function members */
+ public:
+  /* Copy Constructor */
+  run_ADA(run_ADA const&) = delete;
+
+  /* Assignment Operator */
+  run_ADA& operator= (run_ADA const&) & = delete;
+
+  /* Move Constructor */
+  run_ADA(run_ADA &&) = delete;
+
+  /* Move Assignment Operator */
+  run_ADA& operator= (run_ADA &&) = delete;
+
+  /* Real-Time Model get method */
+  RT_MODEL_run_ADA_T * getRTM();
+
+  /* Root inports set method */
+  void setExternalInputs(const ExtU_run_ADA_T *pExtU_run_ADA_T)
+  {
+    run_ADA_U = *pExtU_run_ADA_T;
+  }
+
+  /* Root outports get method */
+  const ExtY_run_ADA_T &getExternalOutputs() const
+  {
+    return run_ADA_Y;
+  }
+
+  /* Initial conditions function */
+  void initialize();
+
+  /* model step function */
+  void step();
+
+  /* model terminate function */
+  static void terminate();
+
+  /* Constructor */
+  run_ADA();
+
+  /* Destructor */
+  ~run_ADA();
+
+  /* private data and function members */
+ private:
+  /* External inputs */
+  ExtU_run_ADA_T run_ADA_U;
+
+  /* External outputs */
+  ExtY_run_ADA_T run_ADA_Y;
+
+  /* Block signals */
+  B_run_ADA_T run_ADA_B;
+
+  /* Block states */
+  DW_run_ADA_T run_ADA_DW;
+
+  /* private member function(s) for subsystem '<Root>/run_ADA'*/
+  static void run_ADA_run_ADA_Init(DW_run_ADA_run_ADA_T *localDW);
+  void run_ADA_run_ADA(real_T rtu_Pressure, B_run_ADA_run_ADA_T *localB,
+                       DW_run_ADA_run_ADA_T *localDW) const;
+
+  /* Real-Time Model */
+  RT_MODEL_run_ADA_T run_ADA_M;
+};
+
+/*-
+ * These blocks were eliminated from the model due to optimizations:
+ *
+ * Block '<S2>/Reshape' : Reshape block reduction
+ * Block '<S2>/Reshape2' : Reshape block reduction
+ */
+
+/*-
+ * The generated code includes comments that allow you to trace directly
+ * back to the appropriate location in the model.  The basic format
+ * is <system>/block_name, where system is the system number (uniquely
+ * assigned by Simulink) and block_name is the name of the block.
+ *
+ * Note that this particular code originates from a subsystem build,
+ * and has its own system numbers different from the parent model.
+ * Refer to the system hierarchy for this subsystem below, and use the
+ * MATLAB hilite_system command to trace the generated code back
+ * to the parent model.  For example,
+ *
+ * hilite_system('test_ada/run_ADA')    - opens subsystem test_ada/run_ADA
+ * hilite_system('test_ada/run_ADA/Kp') - opens and selects block Kp
+ *
+ * Here is the system hierarchy for this model
+ *
+ * '<Root>' : 'test_ada'
+ * '<S1>'   : 'test_ada/run_ADA'
+ * '<S2>'   : 'test_ada/run_ADA/Correction'
+ * '<S3>'   : 'test_ada/run_ADA/Prediction'
+ * '<S4>'   : 'test_ada/run_ADA/getAltitude'
+ * '<S5>'   : 'test_ada/run_ADA/getVelocity'
+ */
+#endif                                 /* RTW_HEADER_run_ADA_h_ */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_data.cpp b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_data.cpp
new file mode 100644
index 000000000..c75ebc634
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_data.cpp
@@ -0,0 +1,41 @@
+/*
+ * run_ADA_data.cpp
+ *
+ * Academic License - for use in teaching, academic research, and meeting
+ * course requirements at degree granting institutions only.  Not for
+ * government, commercial, or other organizational use.
+ *
+ * Code generation for model "run_ADA".
+ *
+ * Model version              : 1.25
+ * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022
+ * C++ source code generated on : Wed Oct 25 17:58:39 2023
+ *
+ * Target selection: grt.tlc
+ * Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: Intel->x86-64 (Windows64)
+ * Code generation objective: Execution efficiency
+ * Validation result: Not run
+ */
+
+#include "run_ADA.h"
+
+/* Constant parameters (default storage) */
+const ConstP_run_ADA_T run_ADA_ConstP{
+  /* Expression: [1 0.02 0.5*0.02^2; 0 1 0.02; 0 0 1]
+   * Referenced by: '<S1>/F_memory'
+   */
+  { 1.0, 0.0, 0.0, 0.02, 1.0, 0.0, 0.0002, 0.02, 1.0 },
+
+  /* Pooled Parameter (Expression: eye(3))
+   * Referenced by:
+   *   '<S1>/P_memory'
+   *   '<S2>/I'
+   */
+  { 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 },
+
+  /* Expression: [30 0 0; 0 10 0; 0 0 2.5]
+   * Referenced by: '<S1>/Q_memory'
+   */
+  { 30.0, 0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 2.5 }
+};
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_private.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_private.h
new file mode 100644
index 000000000..f8ee91da1
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_private.h
@@ -0,0 +1,26 @@
+/*
+ * run_ADA_private.h
+ *
+ * Academic License - for use in teaching, academic research, and meeting
+ * course requirements at degree granting institutions only.  Not for
+ * government, commercial, or other organizational use.
+ *
+ * Code generation for model "run_ADA".
+ *
+ * Model version              : 1.25
+ * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022
+ * C++ source code generated on : Wed Oct 25 17:58:39 2023
+ *
+ * Target selection: grt.tlc
+ * Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: Intel->x86-64 (Windows64)
+ * Code generation objective: Execution efficiency
+ * Validation result: Not run
+ */
+
+#ifndef RTW_HEADER_run_ADA_private_h_
+#define RTW_HEADER_run_ADA_private_h_
+#include "rtwtypes.h"
+#include "multiword_types.h"
+#include "run_ADA_types.h"
+#endif                                 /* RTW_HEADER_run_ADA_private_h_ */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_types.h b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_types.h
new file mode 100644
index 000000000..bf526cd98
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/ADA/run_ADA_grt_rtw/run_ADA_types.h
@@ -0,0 +1,43 @@
+/*
+ * run_ADA_types.h
+ *
+ * Academic License - for use in teaching, academic research, and meeting
+ * course requirements at degree granting institutions only.  Not for
+ * government, commercial, or other organizational use.
+ *
+ * Code generation for model "run_ADA".
+ *
+ * Model version              : 1.25
+ * Simulink Coder version : 9.9 (R2023a) 19-Nov-2022
+ * C++ source code generated on : Wed Oct 25 17:58:39 2023
+ *
+ * Target selection: grt.tlc
+ * Note: GRT includes extra infrastructure and instrumentation for prototyping
+ * Embedded hardware selection: Intel->x86-64 (Windows64)
+ * Code generation objective: Execution efficiency
+ * Validation result: Not run
+ */
+
+#ifndef RTW_HEADER_run_ADA_types_h_
+#define RTW_HEADER_run_ADA_types_h_
+#include "rtwtypes.h"
+#ifndef DEFINED_TYPEDEF_FOR_ADAState_
+#define DEFINED_TYPEDEF_FOR_ADAState_
+
+struct ADAState
+{
+  real_T timestamp;
+  real_T mslAltitude;
+  real_T aglAltitude;
+  real_T verticalSpeed;
+  real_T x0;
+  real_T x1;
+  real_T x2;
+};
+
+#endif
+
+/* Forward declaration for rtModel */
+typedef struct tag_RTM_run_ADA_T RT_MODEL_run_ADA_T;
+
+#endif                                 /* RTW_HEADER_run_ADA_types_h_ */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/extern/include/tmwtypes.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/extern/include/tmwtypes.h
new file mode 100644
index 000000000..e7f52fc38
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/extern/include/tmwtypes.h
@@ -0,0 +1,888 @@
+/*
+ * Copyright 1984-2018 The MathWorks, Inc.
+ */
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3))
+# pragma once
+#endif
+
+#ifndef tmwtypes_h
+#define tmwtypes_h
+
+#ifndef __TMWTYPES__
+#define __TMWTYPES__
+/*
+ * File    : tmwtypes.h
+ * Abstract:
+ *      Data types for use with MATLAB/SIMULINK and the Real-Time Workshop.
+ *
+ *      When compiling stand-alone model code, data types can be overridden
+ *      via compiler switches.
+ *
+ *      Define NO_FLOATS to eliminate reference to real_T, etc.
+ */
+
+#ifdef MW_LIBTOOLING
+#include "mwstdint.h"
+#endif
+
+#include <limits.h>
+
+/* __STDC_VERSION__ version check below means "check for a C99 compiler".
+
+   Visual Studio (checked on versions 2015 and 2017) does
+   not define __STDC_VERSION__, however  it has stdbool.h available,
+   thus a separate check for _MSC_VER below.
+ */
+#if defined(__APPLE_CC__) \
+    || (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) \
+    || (defined(_MSC_VER) && (_MSC_VER >= 1900))
+#ifndef tmwtypes_do_not_include_stdbool
+#include <stdbool.h>
+#endif
+#endif
+
+#define LOGICAL_IS_A_TYPE
+#define SPARSE_GENERALIZATION
+
+#ifdef NO_FLOATS
+# define double double_not_allowed
+# define float  float_not_allowed
+#endif /*NO_FLOATS*/
+
+#ifndef NO_FLOATS
+
+#ifndef __MWERKS__
+# ifdef __STDC__
+#  include <float.h>
+# else
+#  ifndef FLT_MANT_DIG
+#   define FLT_MANT_DIG 24
+#  endif
+#  ifndef DBL_MANT_DIG
+#   define DBL_MANT_DIG 53
+#  endif
+# endif
+#endif
+
+#endif /*NO_FLOATS*/
+
+/*
+ *      The following data types cannot be overridden when building MEX files.
+ */
+#ifdef MATLAB_MEX_FILE
+# undef CHARACTER_T
+# undef INTEGER_T
+# undef BOOLEAN_T
+# undef REAL_T
+# undef TIME_T
+#endif
+
+/*
+ * The uchar_T, ushort_T and ulong_T types are needed for compilers which do 
+ * not allow defines to be specified, at the command line, with spaces in them.
+ */
+
+typedef unsigned char       uchar_T;
+typedef unsigned short      ushort_T;
+typedef unsigned long       ulong_T;
+
+#if (defined(_MSC_VER) && _MSC_VER >= 1500)      \
+    || defined(__x86_64__) || defined(__LP64__)  \
+    || defined(__LCC64__)
+    
+typedef unsigned long long  ulonglong_T;
+#endif
+
+
+
+/*=======================================================================*
+ * Fixed width word size data types:                                     *
+ *   int8_T, int16_T, int32_T     - signed 8, 16, or 32 bit integers     *
+ *   uint8_T, uint16_T, uint32_T  - unsigned 8, 16, or 32 bit integers   *
+ *   real32_T, real64_T           - 32 and 64 bit floating point numbers *
+ *=======================================================================*/
+
+/* When used with Real Time Workshop generated code, this
+ * header file can be used with a variety of compilers.
+ *
+ * The compiler could be for an 8 bit embedded processor that
+ * only had 8 bits per integer and 16 bits per long.
+ * In that example, a 32 bit integer size is not even available.
+ * This header file should be robust to that.   
+ *
+ * For the case of an 8 bit processor, the preprocessor
+ * may be limited to 16 bit math like its target.  That limitation 
+ * would mean that 32 bit comparisons can't be done accurately.  
+ * To increase robustness to this, comparisons are done against
+ * smaller values first.  An inaccurate 32 bit comparison isn't
+ * attempted if the 16 bit comparison has already succeeded.
+ *
+ * Limitations on preprocessor math can also be stricter than
+ * for the target.  There are known cases where a compiler
+ * targeting processors with 64 bit longs can't do accurate
+ * preprocessor comparisons on more than 32 bits.  
+ */
+
+/* Determine the number of bits for int, long, short, and char.
+ * If one fails to be determined, set the number of bits to -1
+ */
+
+#ifndef TMW_BITS_PER_INT
+# if   INT_MAX  == 0x7FL
+#  define TMW_BITS_PER_INT 8
+# elif INT_MAX  == 0x7FFFL
+#  define TMW_BITS_PER_INT 16
+# elif INT_MAX  == 0x7FFFFFFFL
+#  define TMW_BITS_PER_INT 32
+# else
+#  define TMW_BITS_PER_INT -1
+# endif
+#endif
+
+#ifndef TMW_BITS_PER_LONG
+# if   LONG_MAX  == 0x7FL
+#  define TMW_BITS_PER_LONG 8
+# elif LONG_MAX  == 0x7FFFL
+#  define TMW_BITS_PER_LONG 16
+# elif LONG_MAX  == 0x7FFFFFFFL
+#  define TMW_BITS_PER_LONG 32
+# else
+#  define TMW_BITS_PER_LONG -1
+# endif
+#endif
+
+#ifndef TMW_BITS_PER_SHRT
+# if   SHRT_MAX  == 0x7FL
+#  define TMW_BITS_PER_SHRT 8
+# elif SHRT_MAX  == 0x7FFFL
+#  define TMW_BITS_PER_SHRT 16
+# elif SHRT_MAX  == 0x7FFFFFFFL
+#  define TMW_BITS_PER_SHRT 32
+# else
+#  define TMW_BITS_PER_SHRT -1
+# endif
+#endif
+
+#ifndef TMW_BITS_PER_SCHAR
+# if   SCHAR_MAX  == 0x7FL
+#  define TMW_BITS_PER_SCHAR 8
+# elif SCHAR_MAX  == 0x7FFFL
+#  define TMW_BITS_PER_SCHAR 16
+# elif SCHAR_MAX  == 0x7FFFFFFFL
+#  define TMW_BITS_PER_SCHAR 32
+# else
+#  define TMW_BITS_PER_SCHAR -1
+# endif
+#endif
+
+#ifndef TMW_CHAR_SIGNED
+# if SCHAR_MAX == CHAR_MAX
+#  define TMW_CHAR_SIGNED 1
+# else
+#  define TMW_CHAR_SIGNED 0
+# endif
+#endif
+
+/* It is common for one or more of the integer types
+ * to be the same size.  For example, on many embedded
+ * processors, both shorts and ints are 16 bits.  On
+ * processors used for workstations, it is quite common
+ * for both int and long to be 32 bits.  
+ *   When there is more than one choice for typdef'ing
+ * a portable type like int16_T or uint32_T, in
+ * concept, it should not matter which choice is made.
+ * However, some style guides and some code checking
+ * tools do identify and complain about seemingly
+ * irrelevant differences.  For example, a code
+ * checking tool may complain about an implicit
+ * conversion from int to short even though both
+ * are 16 bits.  To reduce these types of
+ * complaints, it is best to make int the
+ * preferred choice when more than one is available.
+ */
+
+#ifndef INT8_T
+# if   defined(MW_LIBTOOLING)
+#  define INT8_T  int8_t
+# elif TMW_BITS_PER_INT   == 8
+#  define  INT8_T int
+# elif TMW_BITS_PER_LONG  == 8
+#  define  INT8_T long
+# elif TMW_BITS_PER_SCHAR == 8
+#  define  INT8_T signed char
+# elif TMW_BITS_PER_SHRT  == 8
+#  define  INT8_T short
+# endif
+#endif
+#ifdef INT8_T
+ typedef INT8_T int8_T;
+#endif
+
+#ifndef UINT8_T
+# if   defined(MW_LIBTOOLING)
+#  define  UINT8_T uint8_t
+# elif   TMW_BITS_PER_INT   == 8
+#  define  UINT8_T unsigned int
+# elif TMW_BITS_PER_LONG  == 8
+#  define  UINT8_T unsigned long
+# elif TMW_BITS_PER_SCHAR == 8
+#  define  UINT8_T unsigned char
+# elif TMW_BITS_PER_SHRT  == 8
+#  define  UINT8_T unsigned short
+# endif
+#endif
+#ifdef UINT8_T
+ typedef UINT8_T uint8_T;
+#endif
+
+
+#ifndef INT16_T
+# if   defined(MW_LIBTOOLING)
+#  define  INT16_T int16_t
+# elif   TMW_BITS_PER_INT   == 16
+#  define  INT16_T int
+# elif TMW_BITS_PER_LONG  == 16
+#  define  INT16_T long
+# elif TMW_BITS_PER_SCHAR == 16
+#  define  INT16_T signed char
+# elif TMW_BITS_PER_SHRT  == 16
+#  define  INT16_T short
+# endif
+#endif
+#ifdef INT16_T
+ typedef INT16_T int16_T;
+#endif
+
+
+#ifndef UINT16_T
+# if   defined(MW_LIBTOOLING)
+#  define  UINT16_T uint16_t
+# elif TMW_BITS_PER_INT   == 16
+#  define  UINT16_T unsigned int
+# elif TMW_BITS_PER_LONG  == 16
+#  define  UINT16_T unsigned long
+# elif TMW_BITS_PER_SCHAR == 16
+#  define  UINT16_T unsigned char
+# elif TMW_BITS_PER_SHRT  == 16
+#  define  UINT16_T unsigned short
+# endif
+#endif
+#ifdef UINT16_T
+ typedef UINT16_T uint16_T;
+#endif
+
+
+#ifndef INT32_T
+# if   defined(MW_LIBTOOLING)
+#  define  INT32_T int32_t
+# elif TMW_BITS_PER_INT   == 32
+#  define  INT32_T int
+# elif TMW_BITS_PER_LONG  == 32
+#  define  INT32_T long
+# elif TMW_BITS_PER_SCHAR == 32
+#  define  INT32_T signed char
+# elif TMW_BITS_PER_SHRT  == 32
+#  define  INT32_T short
+# endif
+#endif
+#ifdef INT32_T
+ typedef INT32_T int32_T;
+#endif
+
+
+#ifndef UINT32_T
+# if   defined(MW_LIBTOOLING)
+#  define  UINT32_T uint32_t
+# elif TMW_BITS_PER_INT   == 32
+#  define  UINT32_T unsigned int
+# elif TMW_BITS_PER_LONG  == 32
+#  define  UINT32_T unsigned long
+# elif TMW_BITS_PER_SCHAR == 32
+#   define UINT32_T unsigned char
+# elif TMW_BITS_PER_SHRT  == 32
+#  define  UINT32_T unsigned short
+# endif
+#endif
+#ifdef UINT32_T
+ typedef UINT32_T uint32_T;
+#endif
+
+/* The following is used to emulate smaller integer types when only
+ * larger types are available.  For example, compilers for TI C3x/C4x DSPs 
+ * define char and short to be 32 bits, so 8 and 16 bits are not directly
+ * available.  This target is commonly used with RTW rapid prototyping.
+ * Other DSPs define char to be 16 bits, so 8 bits is not directly 
+ * available.
+ */
+#ifndef INT8_T
+# ifdef INT16_T
+#  define INT8_T INT16_T
+   typedef INT8_T int8_T;
+# else
+#  ifdef INT32_T
+#   define INT8_T INT32_T
+    typedef INT8_T int8_T;
+#  endif
+# endif
+#endif
+
+#ifndef UINT8_T
+# ifdef UINT16_T
+#   define UINT8_T UINT16_T
+    typedef UINT8_T uint8_T;
+# else
+#  ifdef UINT32_T
+#   define UINT8_T UINT32_T
+    typedef UINT8_T uint8_T;
+#  endif
+# endif
+#endif
+
+#ifndef INT16_T
+# ifdef INT32_T
+#   define INT16_T INT32_T
+    typedef INT16_T int16_T;
+# endif
+#endif
+
+#ifndef UINT16_T
+# ifdef UINT32_T
+#   define UINT16_T UINT32_T
+    typedef UINT16_T uint16_T;
+# endif
+#endif
+
+
+#ifndef NO_FLOATS
+
+#ifndef REAL32_T
+# ifndef __MWERKS__
+#  if FLT_MANT_DIG >= 23
+#   define REAL32_T float
+#  endif
+# else
+#  define REAL32_T float
+# endif
+#endif
+#ifdef REAL32_T
+ typedef REAL32_T real32_T;
+#endif
+
+
+#ifndef REAL64_T
+# ifndef __MWERKS__
+#  if DBL_MANT_DIG >= 52
+#   define REAL64_T double
+#  endif
+# else
+#  define REAL64_T double
+# endif
+#endif
+#ifdef REAL64_T
+ typedef REAL64_T real64_T;
+#endif
+
+#endif /* NO_FLOATS*/
+
+/*=======================================================================*
+ * Fixed width word size data types:                                     *
+ *   int64_T                      - signed 64 bit integers               *
+ *   uint64_T                     - unsigned 64 bit integers             *
+ *=======================================================================*/
+
+# if   defined(MW_LIBTOOLING)
+#  ifdef INT64_T
+#    undef  INT64_T
+#  endif
+#  define  INT64_T int64_t
+#  ifdef UINT64_T
+#    undef  UINT64_T
+#  endif
+#  define  UINT64_T uint64_t
+# endif
+#if !defined(INT64_T) || !defined(UINT64_T) || !defined(FMT64)
+# if defined(__APPLE__) || defined(__clang__)
+#  ifndef INT64_T
+#   define INT64_T long long
+#  endif
+#  ifndef UINT64_T
+#   define UINT64_T unsigned long long
+#  endif
+#  ifndef FMT64
+#   define FMT64 "ll"
+#  endif
+#  if defined(__LP64__) && !defined(INT_TYPE_64_IS_LONG)
+#    define INT_TYPE_64_IS_LONG
+#  endif
+# elif (defined(__x86_64__) || defined(__LP64__))&& !defined(__MINGW64__) 
+#  ifndef INT64_T
+#   define INT64_T long
+#  endif
+#  ifndef UINT64_T
+#   define UINT64_T unsigned long
+#  endif
+#  ifndef FMT64
+#   define FMT64 "l"
+#  endif
+#  if !defined(INT_TYPE_64_IS_LONG)
+#    define INT_TYPE_64_IS_LONG
+#  endif
+# elif defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \
+                         || (defined(__WATCOMC__)  && __WATCOMC__  >= 1100)
+#  ifndef INT64_T
+#   define INT64_T __int64
+#  endif
+#  ifndef UINT64_T
+#   define UINT64_T unsigned __int64
+#  endif
+#  ifndef FMT64
+#   define FMT64 "I64"
+#  endif
+# elif defined(__GNUC__) || defined(TMW_ENABLE_INT64) \
+                         || defined(__LCC64__)
+#  ifndef INT64_T
+#   define INT64_T long long
+#  endif
+#  ifndef UINT64_T
+#   define UINT64_T unsigned long long
+#  endif
+#  ifndef FMT64
+#   define FMT64 "ll"
+#  endif
+# endif
+
+#endif
+
+#if defined(INT64_T)
+# if defined(__GNUC__) && \
+    ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9)))
+  __extension__
+# endif
+ typedef INT64_T int64_T;
+#endif
+
+#if defined(_WIN64) || (defined(__APPLE__) && defined(__LP64__)) \
+                    || defined(__x86_64__) \
+                    || defined(__LP64__)
+#  define INT_TYPE_64_IS_SUPPORTED
+#endif
+
+#if defined(UINT64_T)
+# if defined(__GNUC__) && \
+    ((__GNUC__ > 2) || ((__GNUC__ == 2) && (__GNUC_MINOR__ >=9)))
+  __extension__
+# endif
+ typedef UINT64_T uint64_T;
+#endif
+
+/*===========================================================================*
+ * Format string modifiers for using size_t variables in printf statements.  *
+ *===========================================================================*/
+
+#ifndef FMT_SIZE_T
+#  if (defined( __GNUC__ ) || defined(_STDC_C99))&& !defined(__MINGW64__)
+#    define FMT_SIZE_T "z"
+#  elif defined (__WATCOMC__)
+#    define FMT_SIZE_T "l"
+#  elif defined (_WIN32 )
+#    define FMT_SIZE_T "I"
+#  else
+#    define FMT_SIZE_T "l"
+#  endif
+#endif
+
+#ifndef FMT_PTRDIFF_T
+#  if defined(__APPLE__)
+#    define FMT_PTRDIFF_T "l"
+#  elif defined( __GNUC__ ) || defined(_STDC_C99)
+#    define FMT_PTRDIFF_T "t"
+#  elif defined (__WATCOMC__)
+#    define FMT_PTRDIFF_T "l"
+#  elif defined (_WIN32 )
+#    define FMT_PTRDIFF_T "I"
+#  else
+#    define FMT_PTRDIFF_T "l"
+#  endif
+#endif
+
+/*===========================================================================*
+ * General or logical data types where the word size is not guaranteed.      *
+ *  real_T     - possible settings include real32_T or real64_T              *
+ *  time_T     - possible settings include real32_T or real64_T              *
+ *  boolean_T                                                                *
+ *  char_T                                                                   *
+ *  int_T                                                                    *
+ *  uint_T                                                                   *
+ *  byte_T                                                                   *
+ *===========================================================================*/
+
+#ifndef NO_FLOATS
+
+#ifndef REAL_T
+# ifdef REAL64_T
+#  define REAL_T real64_T
+# else
+#  ifdef REAL32_T
+#   define REAL_T real32_T
+#  endif
+# endif
+#endif
+#ifdef REAL_T
+ typedef REAL_T real_T;
+#endif
+
+#ifndef TIME_T
+# ifdef REAL_T
+#  define TIME_T real_T
+# endif
+#endif
+#ifdef TIME_T
+ typedef TIME_T time_T;
+#endif
+
+#endif /* NO_FLOATS */
+
+#ifndef BOOLEAN_T
+# if defined(UINT8_T)
+#  define BOOLEAN_T UINT8_T
+# else
+#  define BOOLEAN_T unsigned int
+# endif
+#endif
+typedef BOOLEAN_T boolean_T;
+
+
+#ifndef CHARACTER_T
+# define CHARACTER_T char
+#endif
+typedef CHARACTER_T char_T;
+
+
+#ifndef INTEGER_T
+# define INTEGER_T int
+#endif
+typedef INTEGER_T int_T;
+
+
+#ifndef UINTEGER_T
+# define UINTEGER_T unsigned
+#endif
+typedef UINTEGER_T uint_T;
+
+
+#ifndef BYTE_T
+# define BYTE_T unsigned char
+#endif
+typedef BYTE_T byte_T;
+
+
+/*===========================================================================*
+ * Define Complex Structures                                                 *
+ *===========================================================================*/
+#ifndef NO_FLOATS
+
+#ifndef CREAL32_T
+#  ifdef REAL32_T
+    typedef struct {
+      real32_T re, im;
+    } creal32_T;
+#    define CREAL32_T creal32_T
+#  endif
+#endif
+
+#ifndef CREAL64_T
+#  ifdef REAL64_T
+    typedef struct {
+      real64_T re, im;
+    } creal64_T;
+#    define CREAL64_T creal64_T
+#  endif
+#endif
+
+#ifndef CREAL_T
+#  ifdef REAL_T
+    typedef struct {
+      real_T re, im;
+    } creal_T;
+#    define CREAL_T creal_T
+#  endif
+#endif
+
+#endif /* NO_FLOATS */
+
+#ifndef CINT8_T
+#  ifdef INT8_T
+    typedef struct {
+      int8_T re, im;
+    } cint8_T;
+#    define CINT8_T cint8_T
+#  endif
+#endif
+
+#ifndef CUINT8_T
+#  ifdef UINT8_T
+    typedef struct {
+      uint8_T re, im;
+    } cuint8_T;
+#    define CUINT8_T cuint8_T
+#  endif
+#endif
+
+#ifndef CINT16_T
+#  ifdef INT16_T
+    typedef struct {
+      int16_T re, im;
+    } cint16_T;
+#    define CINT16_T cint16_T
+#  endif
+#endif
+
+#ifndef CUINT16_T
+#  ifdef UINT16_T
+    typedef struct {
+      uint16_T re, im;
+    } cuint16_T;
+#    define CUINT16_T cuint16_T
+#  endif
+#endif
+
+#ifndef CINT32_T
+#  ifdef INT32_T
+    typedef struct {
+      int32_T re, im;
+    } cint32_T;
+#    define CINT32_T cint32_T
+#  endif
+#endif
+
+#ifndef CUINT32_T
+#  ifdef UINT32_T
+    typedef struct {
+      uint32_T re, im;
+    } cuint32_T;
+#    define CUINT32_T cuint32_T
+#  endif
+#endif
+
+#ifndef CINT64_T
+#  ifdef INT64_T
+    typedef struct {
+      int64_T re, im;
+    } cint64_T;
+#    define CINT64_T cint64_T
+#  endif
+#endif
+
+#ifndef CUINT64_T
+#  ifdef UINT64_T
+    typedef struct {
+      uint64_T re, im;
+    } cuint64_T;
+#    define CUINT64_T cuint64_T
+#  endif
+#endif
+
+/*=======================================================================*
+ * Min and Max:                                                          *
+ *   int8_T, int16_T, int32_T     - signed 8, 16, or 32 bit integers     *
+ *   uint8_T, uint16_T, uint32_T  - unsigned 8, 16, or 32 bit integers   *
+ *=======================================================================*/
+
+#define  MAX_int8_T      ((int8_T)(127))            /* 127  */
+#define  MIN_int8_T      ((int8_T)(-128))           /* -128 */
+#define  MAX_uint8_T     ((uint8_T)(255))           /* 255  */
+#define  MIN_uint8_T     ((uint8_T)(0))
+                           
+#define  MAX_int16_T     ((int16_T)(32767))         /* 32767 */
+#define  MIN_int16_T     ((int16_T)(-32768))        /* -32768 */
+#define  MAX_uint16_T    ((uint16_T)(65535))        /* 65535 */
+#define  MIN_uint16_T    ((uint16_T)(0))
+                           
+#define  MAX_int32_T     ((int32_T)(2147483647))    /* 2147483647  */
+#define  MIN_int32_T     ((int32_T)(-2147483647-1)) /* -2147483648 */
+#define  MAX_uint32_T    ((uint32_T)(0xFFFFFFFFU))  /* 4294967295  */
+#define  MIN_uint32_T    ((uint32_T)(0))
+
+#if defined(_MSC_VER) || (defined(__BORLANDC__) && __BORLANDC__ >= 0x530) \
+                      || (defined(__WATCOMC__)  && __WATCOMC__  >= 1100) \
+                      || defined(__LCC64__)
+#  ifdef INT64_T
+#    define  MAX_int64_T     ((int64_T)(9223372036854775807LL))
+#    define  MIN_int64_T     ((int64_T)(-9223372036854775807LL-1LL))
+#  endif
+#  ifdef UINT64_T
+#    define  MAX_uint64_T    ((uint64_T)(0xFFFFFFFFFFFFFFFFULL))
+#    define  MIN_uint64_T    ((uint64_T)(0))
+#  endif
+#else
+#  ifdef INT64_T
+#    ifdef INT_TYPE_64_IS_LONG
+#      define  MAX_int64_T     ((int64_T)(9223372036854775807L))
+#      define  MIN_int64_T     ((int64_T)(-9223372036854775807L-1L))
+#    else
+#      define  MAX_int64_T     ((int64_T)(9223372036854775807LL))
+#      define  MIN_int64_T     ((int64_T)(-9223372036854775807LL-1LL))
+#    endif
+#  endif
+#  ifdef UINT64_T
+#    ifdef INT_TYPE_64_IS_LONG
+#      define  MAX_uint64_T    ((uint64_T)(0xFFFFFFFFFFFFFFFFUL))
+#      define  MIN_uint64_T    ((uint64_T)(0))
+#    else
+#      define  MAX_uint64_T    ((uint64_T)(0xFFFFFFFFFFFFFFFFULL))
+#      define  MIN_uint64_T    ((uint64_T)(0))
+#    endif
+#  endif
+#endif
+
+#if (defined(_MSC_VER) && !defined(__clang__))
+
+/* Conversion from unsigned __int64 to double is not implemented in Visual Studio
+ * and results in a compile error, thus the value must first be cast to
+ * signed __int64, and then to double.
+ *
+ * If the 64 bit int value is greater than 2^63-1, which is the signed int64 max,
+ * the macro below provides a workaround for casting a uint64 value to a double
+ * in windows.
+ */
+#  define uint64_to_double(u) ( ((u) > _I64_MAX) ? \
+            (double)(__int64)((u) - _I64_MAX - 1) + (double)_I64_MAX + 1: \
+            (double)(__int64)(u) )
+
+/* The following inline function should only be used in the macro double_to_uint64,
+ * as it only handles the specfic range of double between 2^63 and 2^64-1 */
+__forceinline
+uint64_T double_to_uint64_helper(double d) {
+  union double_to_uint64_union_type {
+    double dd;
+    uint64_T i64;
+  } di;
+  di.dd = d;
+  return (((di.i64 & 0x000fffffffffffff) | 0x0010000000000000) << 11);
+}
+
+/* The largest double value that can be cast to uint64 in windows is the
+ * signed int64 max, which is 2^63-1. The macro below provides
+ * a workaround for casting large double values to uint64 in windows.
+ */
+/* The magic number 18446744073709551616.0 is 2^64 */
+/* The magic number 9223372036854775808.0 is 2^63 */
+#  define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \
+            0xffffffffffffffffULL : \
+            ((d) >= 0.0) ? \
+            ((d) >= 9223372036854775808.0) ? \
+            double_to_uint64_helper(d) : \
+            (unsigned __int64)(d) : \
+            0ULL )
+#else
+#  define uint64_to_double(u) ((double)(u))
+#  if defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__TICCSC__)
+/* double_to_uint64 defined only for MSVC and UNIX */
+#  else
+#  define double_to_uint64(d) ( ((d) >= 18446744073709551616.0) ? \
+            (unsigned long long) 0xffffffffffffffffULL : \
+            ((d) >= 0) ? (unsigned long long)(d) : (unsigned long long) 0 )
+#  endif
+#endif
+
+#if !defined(__cplusplus) && !defined(__bool_true_false_are_defined)
+
+#ifndef _bool_T
+#define _bool_T
+
+typedef boolean_T bool;
+
+#ifndef false
+#define false (0)
+#endif
+#ifndef true 
+#define true (1)
+#endif
+
+#endif /* _bool_T */
+
+#endif /* !__cplusplus */
+
+/* 
+ * This software assumes that the code is being compiled on a target using a 
+ * 2's complement representation for signed integer values.
+ */
+#if ((SCHAR_MIN + 1) != -SCHAR_MAX)
+#error "This code must be compiled using a 2's complement representation for signed integer values"
+#endif
+
+/*
+ * Maximum length of a MATLAB identifier (function/variable/model)
+ * including the null-termination character.
+ */
+#define TMW_NAME_LENGTH_MAX 64
+
+/*
+ * Maximum values for indices and dimensions
+ */
+#include <stddef.h>
+
+#ifdef MX_COMPAT_32
+typedef int mwSize;
+typedef int mwIndex;
+typedef int mwSignedIndex;
+#else
+typedef size_t    mwSize;         /* unsigned pointer-width integer */
+typedef size_t    mwIndex;        /* unsigned pointer-width integer */
+typedef ptrdiff_t mwSignedIndex;  /* a signed pointer-width integer */
+#endif
+
+                                  /* for the individual dim */
+/* If updating SLSize or SLIndex, update defintions in sl_types_def.h
+   as well. */
+#ifndef SLSIZE_SLINDEX
+  #define SLSIZE_SLINDEX
+  #ifdef INT_TYPE_64_IS_SUPPORTED
+    typedef int64_T SLIndex;
+    typedef int64_T SLSize;
+  #else
+    typedef int SLIndex;
+    typedef int SLSize;
+  #endif
+#endif
+
+/* for the total size */
+#define SLIndexType size_t
+#define INVALID_SIZET_VALUE   (std::numeric_limits<SLIndexType>::max())
+#define MAX_VALID_SIZET_VALUE   (std::numeric_limits<SLIndexType>::max() -1)
+
+
+#if (defined(_LP64) || defined(_WIN64)) && !defined(MX_COMPAT_32)
+/* Currently 2^48 based on hardware limitations */
+# define MWSIZE_MAX    281474976710655UL
+# define MWINDEX_MAX   281474976710655UL
+# define MWSINDEX_MAX  281474976710655L
+# define MWSINDEX_MIN -281474976710655L
+#else
+# define MWSIZE_MAX    2147483647UL
+# define MWINDEX_MAX   2147483647UL
+# define MWSINDEX_MAX  2147483647L
+# define MWSINDEX_MIN -2147483647L
+#endif
+#define MWSIZE_MIN    0UL
+#define MWINDEX_MIN   0UL
+
+/** UTF-16 character type */
+
+#if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_HAS_CHAR16_T_LANGUAGE_SUPPORT) && _HAS_CHAR16_T_LANGUAGE_SUPPORT)
+typedef char16_t CHAR16_T;
+#define U16_STRING_LITERAL_PREFIX u
+#elif defined(_MSC_VER)
+typedef wchar_t CHAR16_T;
+#define U16_STRING_LITERAL_PREFIX L
+#else
+typedef UINT16_T CHAR16_T;
+#endif
+
+#endif  /* __TMWTYPES__ */
+
+#endif /* tmwtypes_h */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/common/rt_cppclass_main.cpp b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/common/rt_cppclass_main.cpp
new file mode 100644
index 000000000..7d0fb4a3c
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/common/rt_cppclass_main.cpp
@@ -0,0 +1,452 @@
+/* 
+ * Copyright 2013-2022 The MathWorks, Inc.
+ *
+ * File: rt_cppclass_main.cpp
+ *
+ * Abstract:
+ *
+ *   A real-time main that runs generated Simulink Coder code under most 
+ *   operating systems.  Based on the definition of MULTITASKING, a single-task 
+ *   or multitask step function is employed.
+ *
+ *   This file is a useful starting point for creating a custom main when 
+ *   targeting a custom floating point processor or integer micro-controller.
+ *
+ *   Alternatively for ERT targets, you can generate a sample ert_main.cpp file 
+ *   with the generated code by selecting the "Generate an example main program"
+ *   option.  In this case, ert_main.cpp is precisely customized to the
+ *   model requirements.  
+ *
+ * Required Defines:
+ *
+ *   MODEL - Model name
+ *   NUMST - Number of sample times
+ *
+ */
+
+/*==================*
+ * Required defines *
+ *==================*/
+
+#ifndef MODEL
+# error Must specify a model name.  Define MODEL=name.
+#else
+/* create generic macros that work with any model */
+# define EXPAND_CONCAT(name1,name2) name1 ## name2
+# define CONCAT(name1,name2) EXPAND_CONCAT(name1,name2)
+# define MODEL_INSTANCE   CONCAT(MODEL,_Obj)
+#endif
+
+#ifndef NUMST
+# error Must specify the number of sample times.  Define NUMST=number.
+#endif
+
+#if CLASSIC_INTERFACE == 1
+# error "Classic call interface is not supported by rt_cppclass_main.cpp."
+#endif
+
+#if ONESTEPFCN==0
+#error Separate output and update functions are not supported by rt_cppclass_main.cpp. \
+You must update rt_cppclass_main.cpp to suit your application needs, or select \
+the 'Single output/update function' option.
+#endif
+
+#if TERMFCN==0
+#error The terminate function is required by rt_cppclass_main.cpp. \
+Select model configuration parameter 'Terminate function required' \
+or 'Generate an example main program' or modify rt_cppclass_main.cpp to \
+meet your application requirements.
+#endif
+
+#define QUOTE1(name) #name
+#define QUOTE(name) QUOTE1(name)    /* need to expand name    */
+
+#ifndef SAVEFILE
+# define MATFILE2(file) #file ".mat"
+# define MATFILE1(file) MATFILE2(file)
+# define MATFILE MATFILE1(MODEL)
+#else
+# define MATFILE QUOTE(SAVEFILE)
+#endif
+
+/*==========*
+ * Includes *
+ *==========*/
+
+#include "rtwtypes.h"
+#if !defined(INTEGER_CODE) || INTEGER_CODE == 0
+# include <stdio.h>    /* optional for printf */
+#else
+extern "C" {
+  extern int printf(const char *, ...); 
+  extern int fflush(void *);
+}
+#endif
+#include <string.h>  /* optional for strcmp */
+#include "rtmodel.h"  /* includes model.h */
+
+#include "rt_logging.h"
+#ifdef UseMMIDataLogging
+#include "rt_logging_mmi.h"
+#endif
+
+#include "ext_work.h"
+
+#ifdef MODEL_STEP_FCN_CONTROL_USED
+#error rt_cppclass_main.cpp does not support model step function prototype control.
+#endif
+
+/*========================* 
+ * Setup for multitasking * 
+ *========================*/
+
+/* 
+ * Let MT be synonym for MULTITASKING (to shorten command line for DOS) 
+ */
+#if defined(MT)
+# if MT == 0
+# undef MT
+# else
+# define MULTITASKING 1
+# endif
+#endif
+
+#if defined(TID01EQ) && TID01EQ == 1
+#define FIRST_TID 1
+#else 
+#define FIRST_TID 0
+#endif
+
+/*====================*
+ * External functions *
+ *====================*/
+
+#if !defined(MULTITASKING)
+ /* single-rate step function */
+ #define MODEL_STEP(obj) obj.MODEL_STEPNAME()
+#else
+ /* multirate step function */
+ #define MODEL_STEP MODEL_STEPNAME
+#endif
+
+
+/*==================================*
+ * Global data local to this module *
+ *==================================*/
+#ifndef MULTITASKING
+static uint_T OverrunFlags[1];    /* ISR overrun flags */
+static uint_T eventFlags[1];      /* necessary for overlapping preemption */
+#else
+static uint_T OverrunFlags[NUMST];
+static uint_T eventFlags[NUMST]; 
+#endif
+
+/* Create model instance */
+static MODEL_CLASSNAME MODEL_INSTANCE;
+
+
+/*===================*
+ * Visible functions *
+ *===================*/
+
+#if !defined(MULTITASKING) /* single task */
+
+/* Function: rtOneStep ========================================================
+ *
+ * Abstract:
+ *   Perform one step of the model.  This function is modeled such that
+ *   it could be called from an interrupt service routine (ISR) with minor
+ *   modifications.
+ */
+static void rt_OneStep(MODEL_CLASSNAME & mdl)
+{
+    /* Disable interrupts here */
+
+    /***********************************************
+     * Check and see if base step time is too fast *
+     ***********************************************/
+    if (OverrunFlags[0]++) {
+        rtmSetErrorStatus(mdl.getRTM(), "Overrun");
+    }
+
+    /*************************************************
+     * Check and see if an error status has been set *
+     * by an overrun or by the generated code.       *
+     *************************************************/
+    if (rtmGetErrorStatus(mdl.getRTM()) != NULL) {
+        return;
+    }
+
+    /* Save FPU context here (if necessary) */
+    /* Re-enable interrupts here */
+    /* Set model inputs here */
+
+    /**************
+     * Step model *
+     **************/
+    MODEL_STEP(mdl);
+
+    /* Get model outputs here */
+
+    /**************************
+     * Decrement overrun flag *
+     **************************/
+    OverrunFlags[0]--;
+
+    rtExtModeCheckEndTrigger();
+
+    /* Disable interrupts here */
+    /* Restore FPU context here (if necessary) */
+    /* Re-enable interrupts here */
+
+} /* end rtOneStep */
+
+#else /* multitask */
+
+/* Function: rtOneStep ========================================================
+ *
+ * Abstract:
+ *   Perform one step of the model.  This function is modeled such that
+ *   it could be called from an interrupt service routine (ISR) with minor
+ *   modifications.
+ *
+ *   Note that error checking is only necessary when this routine is
+ *   attached to an interrupt.
+ *
+ *   Also, you may wish to unroll any or all of for and while loops to
+ *   improve the real-time performance of this function.
+ */
+static void rt_OneStep(MODEL_CLASSNAME & mdl)
+{
+    int_T i;
+
+    /* Disable interrupts here */
+
+    /***********************************************
+     * Check and see if base step time is too fast *
+     ***********************************************/
+    if (OverrunFlags[0]++) {
+        rtmSetErrorStatus(mdl.getRTM(), "Overrun");
+    }
+
+    /*************************************************
+     * Check and see if an error status has been set *
+     * by an overrun or by the generated code.       *
+     *************************************************/
+    if (rtmGetErrorStatus(mdl.getRTM()) != NULL) {
+        return;
+    }
+
+    /* Save FPU context here (if necessary) */
+    /* Re-enable interrupts here */
+    
+    /*************************************************
+     * Update EventFlags and check subrate overrun   *
+     *************************************************/
+    for (i = FIRST_TID+1; i < NUMST; i++) {
+        if (rtmStepTask(mdl.getRTM(),i) && eventFlags[i]++) {
+            OverrunFlags[0]--;
+            OverrunFlags[i]++;
+            /* Sampling too fast */
+            rtmSetErrorStatus(mdl.getRTM(), "Overrun");
+            return;
+        }
+        if (++rtmTaskCounter(mdl.getRTM(),i) == rtmCounterLimit(mdl.getRTM(),i))
+            rtmTaskCounter(mdl.getRTM(), i) = 0;
+    }
+
+    /* Set model inputs associated with base rate here */
+
+    /*******************************************
+     * Step the model for the base sample time *
+     *******************************************/
+    MODEL_STEP(mdl,0);
+
+    /* Get model outputs associated with base rate here */
+
+    /************************************************************************
+     * Model step complete for base sample time, now it is okay to          *
+     * re-interrupt this ISR.                                               *
+     ************************************************************************/
+    OverrunFlags[0]--;
+
+    /*********************************************************
+     * Step the model for any other sample times (subrates) *
+     *********************************************************/
+    for (i = FIRST_TID+1; i < NUMST; i++) {
+        /*************************************************************
+         * If task "i" is running, don't run any lower priority task *
+         *************************************************************/
+        if (OverrunFlags[i]) return; 
+
+        if (eventFlags[i]) {
+            OverrunFlags[i]++;
+
+            /* Set model inputs associated with subrate here */
+
+            /******************************************
+             * Step the model for sample time "i" *
+             ******************************************/
+            MODEL_STEP(mdl,i);
+
+            /* Get model outputs associated with subrate here */
+            
+            /**********************************************
+             * Indicate task complete for sample time "i" *
+             **********************************************/
+            OverrunFlags[i]--;
+            eventFlags[i]--;
+        }
+    }
+
+    rtExtModeCheckEndTrigger();
+    /* Disable interrupts here */
+    /* Restore FPU context here (if necessary) */
+    /* Enable interrupts here */
+
+} /* end rtOneStep */
+
+#endif /* MULTITASKING */
+
+/* Function: rt_InitModel ====================================================
+ * 
+ * Abstract: 
+ *   Initialized the model and the overrun flags
+ *
+ */
+static void rt_InitModel(MODEL_CLASSNAME & mdl)
+{
+#if defined(MULTITASKING)
+    int i;
+    for(i=0; i < NUMST; i++) {
+        OverrunFlags[i] = 0;
+        eventFlags[i] = 0;
+    }
+#else
+    OverrunFlags[0] = 0;
+    eventFlags[0] = 0;
+#endif
+
+    /************************
+     * Initialize the model *
+     ************************/
+    mdl.initialize();
+}
+
+/* Function: rt_TermModel ====================================================
+ * 
+ * Abstract:
+ *   Terminates the model and prints the error status
+ *
+ */
+static int_T rt_TermModel(MODEL_CLASSNAME & mdl)
+{
+    mdl.terminate();
+    
+    {
+        const char_T *errStatus = (const char_T *) (rtmGetErrorStatus(mdl.getRTM()));
+        
+        if (errStatus != NULL && strcmp(errStatus, "Simulation finished")) {
+            (void)printf("%s\n", errStatus);
+#if defined(MULTITASKING)
+            int_T i;
+            for (i = 0; i < NUMST; i++) {
+                if (OverrunFlags[i]) {
+                    (void)printf("ISR overrun - sampling rate too"
+                                 "fast for sample time index %d.\n", i);
+                }
+            }
+#else
+            if (OverrunFlags[0]) {
+                    (void)printf("ISR overrun - base sampling rate too fast.\n");
+                }
+#endif
+            
+            return(1);
+        }
+    }
+    
+    return(0);
+}
+
+/* Function: main =============================================================
+ *
+ * Abstract:
+ *   Execute model on a generic target such as a workstation.
+ */
+int_T main(int_T argc, const char *argv[])
+{
+    int_T ret;
+
+    /* External mode */
+    rtParseArgsForExtMode(argc, argv);
+ 
+    /*******************************************
+     * warn if the model will run indefinitely *
+     *******************************************/
+#ifndef EXT_MODE
+# define EXT_MODE 0
+#endif
+
+#if MAT_FILE==0 && EXT_MODE==0
+    printf("warning: the simulation will run with no stop time; "
+           "to change this behavior select the 'MAT-file logging' option\n");
+    fflush(NULL);
+#endif
+
+    /************************
+     * Initialize the model *
+     ************************/
+    rt_InitModel(MODEL_INSTANCE);
+
+    /* External mode */
+    rtSetTFinalForExtMode(&rtmGetTFinal(MODEL_INSTANCE.getRTM()));
+    rtExtModeCheckInit(NUMST);
+    rtExtModeWaitForStartPkt(rtmGetRTWExtModeInfo(MODEL_INSTANCE.getRTM()),
+                             NUMST,
+                             (boolean_T *)&rtmGetStopRequested(MODEL_INSTANCE.getRTM()));
+
+    (void)printf("\n** starting the model **\n");
+
+    /***********************************************************************
+     * Execute (step) the model.  You may also attach rtOneStep to an ISR, *
+     * in which case you replace the call to rtOneStep with a call to a    *
+     * background task.  Note that the generated code sets error status    *
+     * to "Simulation finished" when MatFileLogging is specified in TLC.   *
+     ***********************************************************************/
+    while (rtmGetErrorStatus(MODEL_INSTANCE.getRTM()) == NULL &&
+           !rtmGetStopRequested(MODEL_INSTANCE.getRTM())) {
+
+        rtExtModePauseIfNeeded(rtmGetRTWExtModeInfo(MODEL_INSTANCE.getRTM()),
+                               NUMST,
+                               (boolean_T *)&rtmGetStopRequested(MODEL_INSTANCE.getRTM()));
+
+        if (rtmGetStopRequested(MODEL_INSTANCE.getRTM())) break;
+
+        /* external mode */
+        rtExtModeOneStep(rtmGetRTWExtModeInfo(MODEL_INSTANCE.getRTM()),
+                         NUMST,
+                         (boolean_T *)&rtmGetStopRequested(MODEL_INSTANCE.getRTM()));
+        
+        rt_OneStep(MODEL_INSTANCE);
+    }
+
+    /*******************************
+     * Cleanup and exit (optional) *
+     *******************************/
+
+#ifdef UseMMIDataLogging
+    rt_CleanUpForStateLogWithMMI(rtmGetRTWLogInfo(MODEL_INSTANCE.getRTM()));
+#endif
+    rt_StopDataLogging(MATFILE,rtmGetRTWLogInfo(MODEL_INSTANCE.getRTM()));
+
+    ret = rt_TermModel(MODEL_INSTANCE);
+
+    rtExtModeShutdown(NUMST);
+
+    return ret;
+}
+
+/* [EOF] rt_cppclass_main.cpp */
+
+
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/ext_mode/common/ext_work.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/ext_mode/common/ext_work.h
new file mode 100644
index 000000000..e7f132238
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/ext_mode/common/ext_work.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright 1994-2012 The MathWorks, Inc.
+ *
+ * File: ext_work.h     
+ *
+ * Abstract:
+ *   
+ */
+
+#ifndef __EXT_WORK_OBJECT__
+#define __EXT_WORK_OBJECT__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef EXT_MODE
+#include "ext_types.h"
+
+#if defined(VXWORKS)
+    /*VxWorks headers*/
+    #include <vxWorks.h>
+    #include <taskLib.h>
+    #include <sysLib.h>
+    #include <semLib.h>
+    #include <rebootLib.h>
+    #include <logLib.h>
+
+    extern void rtExtModeTornadoStartup(RTWExtModeInfo *ei,
+                                        int_T          numSampTimes,
+                                        boolean_T      *stopReqPtr,
+                                        int_T          priority,
+                                        int32_T        stack_size,
+                                        SEM_ID         startStopSem);
+
+    extern void rtExtModeTornadoCleanup(int_T numSampTimes);
+
+    extern void rtExtModeTornadoSetPortInExtUD(const int_T port);
+
+#elif defined(C6000_EXT_MODE)
+    /* C6000 headers*/
+    #include <std.h>
+    #include <stddef.h>
+    #include <sem.h>
+
+    extern void rtExtModeC6000Startup( RTWExtModeInfo *ei,
+                                       int_T          numSampTimes,
+                                       boolean_T      *stopReqPtr);
+
+    extern void rtExtModeC6000Cleanup(int_T numSampTimes);
+#else
+    extern void rtExtModePauseIfNeeded(RTWExtModeInfo *ei,
+                                       int_T          numSampTimes,
+                                       boolean_T      *stopReqPtr);
+
+    extern void rtExtModeWaitForStartPkt(RTWExtModeInfo *ei,
+                                         int_T          numSampTimes,
+                                         boolean_T      *stopReqPtr);
+    void rtExtModeInitUD(void);
+#endif /* #if defined(VXWORKS) */
+
+extern void rtExtModeOneStep(RTWExtModeInfo *ei,
+                             int_T          numSampTimes,
+                             boolean_T      *stopReqPtr);
+
+extern void rtExtModeCheckEndTrigger(void);
+
+extern void rtExtModeUploadCheckTrigger(int_T numSampTimes);
+
+extern void rtExtModeUpload(int_T tid,
+                            real_T taskTime);
+
+extern void rtExtModeCheckInit(int_T numSampTimes);
+
+extern void rtExtModeShutdown(int_T numSampTimes);
+
+extern void rtExtModeParseArgs(int_T        argc, 
+                               const char_T *argv[],
+                               real_T       *rtmFinal);
+
+extern void rtERTExtModeSetTFinal(real_T *rtmTFinal);
+extern void rtSetTFinalForExtMode(real_T *rtmTFinal);
+
+extern void rtParseArgsForExtMode(int_T        argc, 
+                                  const char_T *argv[]);
+
+extern void rtERTExtModeStartMsg(void);
+
+#else /* #ifdef EXTMODE */
+
+#if defined(VXWORKS)
+    #define rtExtModeTornadoStartup(ei,                          \
+                                    numSampTimes,                \
+                                    stopReqPtr,                  \
+                                    priority,                    \
+                                    stack_size,                  \
+                                    startStopSem) /* do nothing */
+    #define rtExtModeTornadoCleanup(numSampTimes); /* do nothing */
+    #define rtExtModeTornadoSetPortInExtUD(port); /* do nothing */
+#elif defined(C6000_EXT_MODE)  
+    #define rtExtModePauseIfNeeded(ei,st,sr) /* do nothing */
+    #define rtExtModeWaitForStartPkt(ei,st,sr) /* do nothing */
+#else
+    #define rtExtModePauseIfNeeded(ei,st,sr) /* do nothing */
+    #define rtExtModeWaitForStartPkt(ei,st,sr) /* do nothing */
+#endif /* #ifdef VXWORKS */
+
+#define rtExtModeOneStep(ei,st,sr) /* do nothing */
+#define rtExtModeCheckEndTrigger() /* do nothing */
+#define rtExtModeUploadCheckTrigger(numSampTimes) /* do nothing */
+#define rtExtModeUpload(t,ttime) /* do nothing */
+#define rtExtModeCheckInit(numSampTimes) /* do nothing */
+#define rtExtModeShutdown(numSampTimes) /* do nothing */
+#define rtExtModeParseArgs(argc, argv, tf); /* do nothing */
+#define rtERTExtModeSetTFinal(tf); /* do nothing */
+#define rtSetTFinalForExtMode(tf); /* do nothing */
+#define rtParseArgsForExtMode(argc, argv); (void)(argc); \
+                                           (void)(argv);
+#define rtERTExtModeStartMsg(); /* do nothing */
+
+#endif  /* #ifdef EXTMODE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __EXT_WORK_OBJECT__ */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/rt_logging.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/rt_logging.h
new file mode 100644
index 000000000..954f55ee5
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/rtw/c/src/rt_logging.h
@@ -0,0 +1,290 @@
+/* Copyright 2012-2022 The MathWorks, Inc. */
+
+#ifndef rt_logging_h
+#define rt_logging_h
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+#if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3))
+# pragma once
+#endif
+
+#if !defined(MAT_FILE) || (defined(MAT_FILE) && MAT_FILE == 1)
+
+#include <stddef.h>                     /* size_t */
+#include "rtwtypes.h"
+#include "builtin_typeid_types.h"
+#include "multiword_types.h"
+#ifdef IS_RAPID_ACCEL
+#include "matrix.h"
+#else
+#include "rt_mxclassid.h"
+#endif
+#include "rtw_matlogging.h"
+
+#ifndef TMW_NAME_LENGTH_MAX
+#define TMW_NAME_LENGTH_MAX 64
+#endif
+#define mxMAXNAM  TMW_NAME_LENGTH_MAX	/* maximum name length */
+
+/*=========*
+ * Defines *
+ *=========*/
+
+/*
+ * Logging related functions and data structures
+ */
+typedef double MatReal;                /* "real" data type used in model.mat  */
+typedef struct LogVar_Tag LogVar;
+typedef struct StructLogVar_Tag StructLogVar;
+
+typedef struct MatrixData_Tag {
+  char_T         name[mxMAXNAM];     /* Name of the variable                  */
+  int_T          nRows;              /* number of rows                        */
+  int_T          nCols;              /* number of columns                     */
+  int_T          nDims;              /* number of dimensions                  */
+  int_T          _dims[2];           /* most cases, dimensions are 2          */
+  int_T          *dims;              /* dimensions of the log variable we 
+                                        write to at each simulation time step.
+                                        E.g: (1) Non-frame data - 
+                                                 Signal dimension = [2 X 3]
+                                                 numDims = 2
+                                                 dims[0] = 2, dims[1] = 3
+                                             (2) Frame data - 
+                                                 Signal dimension = [2 X 3]
+                                                 numDims = 1
+                                                 dims[0] = 3                  */
+  void           *re;                /* pointer to real part of the data      */
+  void           *im;                /* pointer to imaginary part, if complex */
+  DTypeId        dTypeID;            /* data type id                          */
+  size_t         elSize;             /* element size in bytes                 */
+
+  RTWLogDataTypeConvert dataTypeConvertInfo;
+
+  mxClassID      mxID;               /* mxId corresponding to this dTypeID    */
+  uint32_T       logical;            /* is this a logical array ?             */
+  uint32_T       complex;            /* is this a complex matrix?             */
+  uint32_T       frameData;          /* is this data frame based?             */
+  uint32_T       frameSize;          /* is this data frame based?             */
+} MatrixData;
+
+typedef struct ValDimsData_Tag {
+  char_T         name[mxMAXNAM];     /* Name of the variable                  */
+  int_T          nRows;              /* number of rows                        */
+  int_T          nCols;              /* number of columns                     */
+  void           **currSigDims;      /* dimensions of current output          */
+  int_T          *currSigDimsSize;   /* size in bytes of current sig dims     */
+  real_T         *dimsData;          /* pointer to the value of dimension     */
+} ValDimsData;
+
+struct LogVar_Tag {
+    MatrixData  data;                 /* Container for name, data etc.,       */
+    ValDimsData *valDims;             /* field of valueDimensions
+                                       1. If all logging signals are fixed-size,
+                                          then we set this field to NULL;
+                                       2. If any logging signal is variable-size,
+                                          then this field will be needed:
+                                         1) For fixed-size signal, this field is
+                                            an empty matrix;
+                                         2) Otherwise, it contains the dimension
+                                            information of the logging signal.
+                                      */
+    int_T      rowIdx;                /* current row index                    */
+    int_T      wrapped;               /* number of times the circular buffer
+                                       * has wrapped around                   */
+    int_T     nDataPoints;            /* total number of data points logged   */
+    int_T     usingDefaultBufSize;    /* used to print a message at end       */
+    int_T     okayToRealloc;          /* reallocate during sim?               */
+    int_T     decimation;             /* decimation factor                    */
+    int_T     numHits;                /* decimation hit count                 */
+
+    int_T     *coords;
+    int_T     *strides;
+    int_T     *currStrides;           /* coords, strides and currStrides will be
+                                         needed when logging variable-size 
+                                         signal to calculate whether the 
+                                         currently logging value is in the range.
+                                         If the current signal is fixed-size,
+                                         these pointers will be set to NULLs;
+                                         otherwise, we allocate memory for them.
+                                         (the size will be nDims in this case)
+                                      */
+
+    LogVar    *next;
+};
+
+typedef struct SignalsStruct_Tag {
+    int_T        numActiveFields;   /* number of active fields                */
+    const char_T *fieldNames;
+    int_T        numSignals;
+    LogVar       *values;
+    MatrixData   *dimensions;
+    MatrixData   *labels;
+    MatrixData   *plotStyles;
+    MatrixData   *titles;
+    MatrixData   *blockNames;
+    MatrixData   *stateNames;
+    MatrixData   *crossMdlRef;
+
+    boolean_T    logValueDimensions; /* If there's any variable-size signal 
+                                         we also should log 'valueDimensions'
+                                         field                                 */
+    boolean_T    *isVarDims;         /* is this signal a variable-size signal? */
+
+} SignalsStruct;
+
+struct StructLogVar_Tag {
+    char_T        name[mxMAXNAM];    /* Name of the ML Struct variable         */
+    int_T         numActiveFields;   /* number of active fields                */
+    boolean_T     logTime;
+    void          *time;
+    SignalsStruct signals;
+    MatrixData    *blockName;
+
+    StructLogVar  *next;
+};
+
+#define matUNKNOWN                  0
+#define	matINT8                     1
+#define	matUINT8                    2
+#define	matINT16                    3
+#define	matUINT16                   4
+#define	matINT32                    5
+#define	matUINT32                   6
+#define	matFLOAT                    7
+#define	matDOUBLE                   9
+#define matINT64                   12
+#define matUINT64                  13
+#define	matMATRIX                  14
+
+/* status of logging "valueDimensions" field */
+/* 
+  NO_LOGVALDIMS: 
+                 No need to log valueDimensions: 
+                 All signals are fixed-sized.
+
+  LOGVALDIMS_EMPTYMX: 
+                 Signals with mixed dimension modes,
+                 and the signal logged currently
+                 is fixed-sized. So set valueDimensions
+                 field to an empty matrix.
+
+  LOGVALDIMS_VARDIMS:
+                 Signal logged currently is variable-sized.
+*/
+typedef enum {
+    NO_LOGVALDIMS,      
+    LOGVALDIMS_EMPTYMX,
+    LOGVALDIMS_VARDIMS
+} LogValDimsStat;
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern mxClassID rt_GetMxIdFromDTypeIdForRSim(BuiltInDTypeId dTypeID);
+
+extern mxClassID rt_GetMxIdFromDTypeId(BuiltInDTypeId dTypeID);
+
+extern LogVar *rt_CreateLogVarWithConvert(
+    RTWLogInfo        *li,
+    const real_T      startTime,
+    const real_T      finalTime,
+    const real_T      inStepSize,
+    const char_T      **errStatus,
+    const char_T      *varName,
+    BuiltInDTypeId    inpDataTypeID,
+    const RTWLogDataTypeConvert *pDataTypeConvertInfo,
+    int_T             logical,
+    int_T             complex,
+    int_T             frameData,
+    int_T             nCols,
+    int_T             nDims,
+    const int_T       *dims,
+    LogValDimsStat    logValDimsStat,
+    void              **currSigDims,
+    int_T             *currSigDimsSize,
+    int_T             maxRows,
+    int_T             decimation,
+    real_T            sampleTime,
+    int_T             appendToLogVarsList);
+
+
+extern LogVar *rt_CreateLogVar(RTWLogInfo        *li,
+                               const real_T      startTime,
+                               const real_T      finalTime,
+                               const real_T      inStepSize,
+                               const char_T      **errStatus,
+                               const char_T      *varName,
+                               BuiltInDTypeId    inpDataTypeID,
+                               int_T             logical,
+                               int_T             complex,
+                               int_T             frameData,
+                               int_T             nCols,
+                               int_T             nDims,
+                               const int_T       *dims,
+                               LogValDimsStat    logValDimsStat,
+                               void              **currSigDims,
+                               int_T             *currSigDimsSize,
+                               int_T             maxRows,
+                               int_T             decimation,
+                               real_T            sampleTime,
+                               int_T             appendToLogVarsList);
+
+extern StructLogVar *rt_CreateStructLogVar(RTWLogInfo              *li,
+                                           const real_T            startTime,
+                                           const real_T            finalTime,
+                                           const real_T            inStepSize,
+                                           const char_T            **errStatus,
+                                           const char_T            *varName,
+                                           boolean_T               logTime,
+                                           int_T                   maxRows,
+                                           int_T                   decimation,
+                                           real_T                  sampleTime,
+                                           const RTWLogSignalInfo  *sigInfo,
+                                           const char_T            *blockName);
+
+
+extern const char_T *rt_StartDataLoggingWithStartTime(RTWLogInfo   *li,
+                                                      const real_T startTime,
+                                                      const real_T finalTime,
+                                                      const real_T stepSize,
+                                                      const char_T **errStatus);
+
+extern const char_T *rt_StartDataLogging(RTWLogInfo   *li,
+                                         const real_T finalTime,
+                                         const real_T stepSize,
+                                         const char_T **errStatus);
+
+extern void rt_UpdateLogVar(LogVar *var, const void *data, boolean_T isVarDims);
+
+extern void rt_UpdateStructLogVar(StructLogVar *var, const real_T *t, const void *data);
+
+extern const char_T *rt_UpdateTXYLogVars(RTWLogInfo *li, time_T *tPtr);
+extern const char_T *rt_UpdateTXXFYLogVars(RTWLogInfo *li, time_T *tPtr, boolean_T updateTXY);
+
+extern void rt_StopDataLoggingImpl(const char_T *file, RTWLogInfo *li, boolean_T isRaccel);
+
+extern void rt_StopDataLogging(const char_T *file, RTWLogInfo *li);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#else /*!defined(MAT_FILE) || (defined(MAT_FILE) && MAT_FILE == 1)*/
+
+#define rt_StartDataLogging(li, finalTime, stepSize, errStatus) NULL /* do nothing */
+#define rt_UpdateTXYLogVars(li, tPtr) NULL /* do nothing */
+#define rt_StopDataLogging(file, li); /* do nothing */
+
+#endif /*!defined(MAT_FILE) || (defined(MAT_FILE) && MAT_FILE == 1)*/
+
+#endif /* rt_logging_h */
+
+/* LocalWords:  curr LOGVALDIMS EMPTYMX VARDIMS
+ */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_continuous.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_continuous.h
new file mode 100644
index 000000000..510f33f9a
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_continuous.h
@@ -0,0 +1,109 @@
+/* Copyright 1990-2022 The MathWorks, Inc. */
+
+/*
+ * File: rtw_continuous.h
+ *
+ * Abstract:
+ *   Type definitions for continuous-time support.
+ *
+ */
+
+#ifndef RTW_CONTINUOUS_H__
+#define RTW_CONTINUOUS_H__
+
+#ifdef MATLAB_MEX_FILE
+#include "tmwtypes.h"
+#else
+#include "rtwtypes.h"
+#endif
+
+/* For models registering MassMatrix */
+typedef enum {
+    SS_MATRIX_NONE,
+    SS_MATRIX_CONSTANT,
+    SS_MATRIX_TIMEDEP,
+    SS_MATRIX_STATEDEP
+} ssMatrixType;
+
+typedef enum {
+    SOLVER_MODE_AUTO, /* only occurs in
+                         mdlInitializeSizes/mdlInitializeSampleTimes */
+    SOLVER_MODE_SINGLETASKING,
+    SOLVER_MODE_MULTITASKING
+} SolverMode;
+
+typedef enum { MINOR_TIME_STEP, MAJOR_TIME_STEP } SimTimeStep;
+
+/* =============================================================================
+ * Model methods object
+ * =============================================================================
+ */
+typedef void (*rtMdlInitializeSizesFcn)(void* rtModel);
+typedef void (*rtMdlInitializeSampleTimesFcn)(void* rtModel);
+typedef void (*rtMdlStartFcn)(void* rtModel);
+typedef void (*rtMdlOutputsFcn)(void* rtModel, int_T tid);
+typedef void (*rtMdlUpdateFcn)(void* rtModel, int_T tid);
+typedef void (*rtMdlDerivativesFcn)(void* rtModel);
+typedef void (*rtMdlProjectionFcn)(void* rtModel);
+typedef void (*rtMdlMassMatrixFcn)(void* rtModel);
+typedef void (*rtMdlForcingFunctionFcn)(void* rtModel);
+typedef void (*rtMdlTerminateFcn)(void* rtModel);
+#ifdef RT_MALLOC
+typedef real_T (*rtMdlDiscreteEventsFcn)(void* pModel,
+                                         int_T rtmNumSampTimes,
+                                         void* rtmTimingData,
+                                         int_T* rtmSampleHitPtr,
+                                         int_T* rtmPerTaskSampleHits);
+#endif
+
+typedef struct _RTWRTModelMethodsInfo_tag {
+    void* rtModelPtr;
+    rtMdlInitializeSizesFcn rtmInitSizesFcn;
+    rtMdlInitializeSampleTimesFcn rtmInitSampTimesFcn;
+    rtMdlStartFcn rtmStartFcn;
+    rtMdlOutputsFcn rtmOutputsFcn;
+    rtMdlUpdateFcn rtmUpdateFcn;
+    rtMdlDerivativesFcn rtmDervisFcn;
+    rtMdlProjectionFcn rtmProjectionFcn;
+    rtMdlMassMatrixFcn rtmMassMatrixFcn;
+    rtMdlForcingFunctionFcn rtmForcingFunctionFcn;
+    rtMdlTerminateFcn rtmTerminateFcn;
+#ifdef RT_MALLOC
+    rtMdlDiscreteEventsFcn rtmDiscreteEventsFcn;
+#endif
+} RTWRTModelMethodsInfo;
+
+#define rtmiSetRTModelPtr(M, rtmp) ((M).rtModelPtr = (rtmp))
+#define rtmiGetRTModelPtr(M) (M).rtModelPtr
+
+#define rtmiSetInitSizesFcn(M, fp) ((M).rtmInitSizesFcn = ((rtMdlInitializeSizesFcn)(fp)))
+#define rtmiSetInitSampTimesFcn(M, fp) \
+    ((M).rtmInitSampTimesFcn = ((rtMdlInitializeSampleTimesFcn)(fp)))
+#define rtmiSetStartFcn(M, fp) ((M).rtmStartFcn = ((rtMdlStartFcn)(fp)))
+#define rtmiSetOutputsFcn(M, fp) ((M).rtmOutputsFcn = ((rtMdlOutputsFcn)(fp)))
+#define rtmiSetUpdateFcn(M, fp) ((M).rtmUpdateFcn = ((rtMdlUpdateFcn)(fp)))
+#define rtmiSetDervisFcn(M, fp) ((M).rtmDervisFcn = ((rtMdlDerivativesFcn)(fp)))
+#define rtmiSetProjectionFcn(M, fp) ((M).rtmProjectionFcn = ((rtMdlProjectionFcn)(fp)))
+#define rtmiSetMassMatrixFcn(M, fp) ((M).rtmMassMatrixFcn = ((rtMdlMassMatrixFcn)(fp)))
+#define rtmiSetForcingFunctionFcn(M, fp) \
+    ((M).rtmForcingFunctionFcn = ((rtMdlForcingFunctionFcn)(fp)))
+#define rtmiSetTerminateFcn(M, fp) ((M).rtmTerminateFcn = ((rtMdlTerminateFcn)(fp)))
+#ifdef RT_MALLOC
+#define rtmiSetDiscreteEventsFcn(M, fp) ((M).rtmDiscreteEventsFcn = ((rtMdlDiscreteEventsFcn)(fp)))
+#endif
+
+#define rtmiInitializeSizes(M) ((*(M).rtmInitSizesFcn)((M).rtModelPtr))
+#define rtmiInitializeSampleTimes(M) ((*(M).rtmInitSampTimesFcn)((M).rtModelPtr))
+#define rtmiStart(M) ((*(M).rtmStartFcn)((M).rtModelPtr))
+#define rtmiOutputs(M, tid) ((*(M).rtmOutputsFcn)((M).rtModelPtr, tid))
+#define rtmiUpdate(M, tid) ((*(M).rtmUpdateFcn)((M).rtModelPtr, tid))
+#define rtmiDerivatives(M) ((*(M).rtmDervisFcn)((M).rtModelPtr))
+#define rtmiProjection(M) ((*(M).rtmProjectionFcn)((M).rtModelPtr))
+#define rtmiMassMatrix(M) ((*(M).rtmMassMatrixFcn)((M).rtModelPtr))
+#define rtmiForcingFunction(M) ((*(M).rtmForcingFunctionFcn)((M).rtModelPtr))
+#define rtmiTerminate(M) ((*(M).rtmTerminateFcn)((M).rtModelPtr))
+#ifdef RT_MALLOC
+#define rtmiDiscreteEvents(M, x1, x2, x3, x4) \
+    ((*(M).rtmDiscreteEventsFcn)((M).rtModelPtr, (x1), (x2), (x3), (x4)))
+#endif
+#endif /* __RTW_CONTINUOUS_H__ */
diff --git a/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_solver.h b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_solver.h
new file mode 100644
index 000000000..40e4d9aa9
--- /dev/null
+++ b/src/boards/Main/StateMachines/ADAController/run_ADA/R2023a/simulink/include/rtw_solver.h
@@ -0,0 +1,292 @@
+/*
+ * File: rtw_solver.h
+ *
+ * Abstract:
+ *   Type definitions for continuous-time solver support.
+ *
+ */
+
+/* Copyright 1990-2021 The MathWorks, Inc. */
+
+#ifndef RTW_SOLVER_H__
+#define RTW_SOLVER_H__
+
+#include "rtw_continuous.h"
+
+/* =============================================================================
+ * Solver object
+ * =============================================================================
+ */
+#ifndef NO_FLOATS /* ERT integer-only */
+/*
+ * Enum for solver tolerance
+ */
+typedef enum {
+    SL_SOLVER_TOLERANCE_AUTO = 0,       /* Set Automatically by Solver */
+    SL_SOLVER_TOLERANCE_LOCAL = 1,      /* Set Locally, e.g., by Blocks */
+    SL_SOLVER_TOLERANCE_GLOBAL = 2,     /* Set Globally, e.g., by Block Diagram */
+    SL_SOLVER_TOLERANCE_UNDEFINED = 255 /* Signal uninitialized */
+} SL_SolverToleranceControlFlag_T;
+
+
+/*
+ * Enum for jacobian method control
+ */
+typedef enum {
+    SL_JM_BD_AUTO = 0,
+    SL_JM_BD_SPARSE_PERTURBATION,
+    SL_JM_BD_FULL_PERTURBATION,
+    SL_JM_BD_SPARSE_ANALYTICAL,
+    SL_JM_BD_FULL_ANALYTICAL
+} slJmBdControl;
+
+
+typedef struct _ssSolverInfo_tag {
+    void* rtModelPtr;
+
+    SimTimeStep* simTimeStepPtr;
+    void* solverData;
+    const char_T* solverName;
+    boolean_T isVariableStepSolver;
+    boolean_T solverNeedsReset;
+    SolverMode solverMode;
+
+    time_T solverStopTime;
+    time_T* stepSizePtr;
+    time_T minStepSize;
+    time_T maxStepSize;
+    time_T fixedStepSize;
+
+    int_T solverShapePreserveControl;
+    int_T solverMaxConsecutiveMinStep;
+    int_T maxNumMinSteps;
+    int_T solverMaxOrder;
+    real_T solverConsecutiveZCsStepRelTol;
+    int_T solverMaxConsecutiveZCs;
+
+    int_T solverExtrapolationOrder;
+    int_T solverNumberNewtonIterations;
+
+    int_T solverRefineFactor;
+    real_T solverRelTol;
+    real_T unused_real_T_1;
+
+    real_T** dXPtr;
+    time_T** tPtr;
+
+    int_T* numContStatesPtr;
+    real_T** contStatesPtr;
+
+    int_T* numPeriodicContStatesPtr;
+    int_T** periodicContStateIndicesPtr;
+    real_T** periodicContStateRangesPtr;
+
+    real_T* zcSignalVector;
+    uint8_T* zcEventsVector;
+    uint8_T* zcSignalAttrib;
+    int_T zcSignalVectorLength;
+    uint8_T* reserved;
+
+    boolean_T foundContZcEvents;
+    boolean_T isAtLeftPostOfContZcEvent;
+    boolean_T isAtRightPostOfContZcEvent;
+    boolean_T adaptiveZcDetection;
+
+    int_T numZcSignals;
+
+    boolean_T stateProjection;
+    boolean_T robustResetMethod;     /* user's preference */
+    boolean_T updateJacobianAtReset; /* S-Fcn request (sticky) */
+    boolean_T consistencyChecking;
+
+    ssMatrixType massMatrixType;
+    int_T massMatrixNzMax;
+    int_T* massMatrixIr;
+    int_T* massMatrixJc;
+    real_T* massMatrixPr;
+
+    const char_T** errStatusPtr;
+
+    RTWRTModelMethodsInfo* modelMethodsPtr;
+    real_T zcThreshold;
+    int_T reserved_1;
+    int_T consecutiveZCsError;
+    boolean_T CTOutputIncnstWithState;
+    boolean_T isComputingJacobian;
+    slJmBdControl solverJacobianMethodControl;
+    int_T ignoredZcDiagnostic;
+    int_T maskedZcDiagnostic;
+    boolean_T isOutputMethodComputed;
+    int_T maxZcBracketingIterations;
+    boolean_T isMinorTimeStepWithModeChange;
+    int_T maxZcPerStep;
+    real_T** zcSignalPtr;
+} ssSolverInfo;
+
+/* Support old name RTWSolverInfo */
+typedef ssSolverInfo RTWSolverInfo;
+
+#define rtsiSetRTModelPtr(S, rtmp) ((S)->rtModelPtr = (rtmp))
+#define rtsiGetRTModelPtr(S) (S)->rtModelPtr
+
+#define rtsiSetSimTimeStepPtr(S, stp) ((S)->simTimeStepPtr = (stp))
+#define rtsiGetSimTimeStepPtr(S) ((S)->simTimeStepPtr)
+#define rtsiGetSimTimeStep(S) *((S)->simTimeStepPtr)
+#define rtsiSetSimTimeStep(S, st) (*((S)->simTimeStepPtr) = (st))
+
+#define rtsiSetSolverData(S, sd) ((S)->solverData = (sd))
+#define rtsiGetSolverData(S) (S)->solverData
+
+#define rtsiSetSolverName(S, sn) ((S)->solverName = (sn))
+#define rtsiGetSolverName(S) (S)->solverName
+
+#define rtsiSetVariableStepSolver(S, vs) ((S)->isVariableStepSolver = (vs))
+#define rtsiIsVariableStepSolver(S) (S)->isVariableStepSolver
+
+#define rtsiSetSolverNeedsReset(S, sn) ((S)->solverNeedsReset = (sn))
+#define rtsiGetSolverNeedsReset(S) (S)->solverNeedsReset
+
+#define rtsiSetContTimeOutputInconsistentWithStateAtMajorStep(S, sn) \
+    ((S)->CTOutputIncnstWithState = (sn))
+#define rtsiGetContTimeOutputInconsistentWithStateAtMajorStep(S) (S)->CTOutputIncnstWithState
+
+#define rtsiSetBlkStateChange(S, sn) ((S)->CTOutputIncnstWithState = (sn))
+#define rtsiGetBlkStateChange(S) (S)->CTOutputIncnstWithState
+
+#define rtsiSetBlockStateForSolverChangedAtMajorStep(S, sn) ((S)->solverNeedsReset = (sn))
+#define rtsiGetBlockStateForSolverChangedAtMajorStep(S) (S)->solverNeedsReset
+
+#define rtsiSetSolverMode(S, sm) ((S)->solverMode = (sm))
+#define rtsiGetSolverMode(S) (S)->solverMode
+
+#define rtsiSetSolverStopTime(S, st) ((S)->solverStopTime = (st))
+#define rtsiGetSolverStopTime(S) (S)->solverStopTime
+
+#define rtsiSetStepSizePtr(S, ssp) ((S)->stepSizePtr = (ssp))
+#define rtsiSetStepSize(S, ss) (*((S)->stepSizePtr) = (ss))
+#define rtsiGetStepSize(S) *((S)->stepSizePtr)
+
+#define rtsiSetMinStepSize(S, ss) (((S)->minStepSize = (ss)))
+#define rtsiGetMinStepSize(S) (S)->minStepSize
+
+#define rtsiSetMaxStepSize(S, ss) ((S)->maxStepSize = (ss))
+#define rtsiGetMaxStepSize(S) (S)->maxStepSize
+
+#define rtsiSetFixedStepSize(S, ss) ((S)->fixedStepSize = (ss))
+#define rtsiGetFixedStepSize(S) (S)->fixedStepSize
+
+#define rtsiSetMaxNumMinSteps(S, mns) ((S)->maxNumMinSteps = (mns))
+#define rtsiGetMaxNumMinSteps(S) (S)->maxNumMinSteps
+
+#define rtsiSetSolverMaxOrder(S, smo) ((S)->solverMaxOrder = (smo))
+#define rtsiGetSolverMaxOrder(S) (S)->solverMaxOrder
+
+#define rtsiSetSolverJacobianMethodControl(S, smcm) \
+    (ssGetSolverInfo(S)->solverJacobianMethodControl = (smcm))
+#define rtsiGetSolverJacobianMethodControl(S) ssGetSolverInfo(S)->solverJacobianMethodControl
+
+#define rtsiSetSolverShapePreserveControl(S, smcm) \
+    (ssGetSolverInfo(S)->solverShapePreserveControl = (smcm))
+#define rtsiGetSolverShapePreserveControl(S) ssGetSolverInfo(S)->solverShapePreserveControl
+
+#define rtsiSetSolverConsecutiveZCsStepRelTol(S, scr) \
+    (ssGetSolverInfo(S)->solverConsecutiveZCsStepRelTol = (scr))
+#define rtsiGetSolverConsecutiveZCsStepRelTol(S) ssGetSolverInfo(S)->solverConsecutiveZCsStepRelTol
+
+#define rtsiSetSolverMaxConsecutiveZCs(S, smcz) \
+    (ssGetSolverInfo(S)->solverMaxConsecutiveZCs = (smcz))
+#define rtsiGetSolverMaxConsecutiveZCs(S) ssGetSolverInfo(S)->solverMaxConsecutiveZCs
+
+#define rtsiSetSolverMaxConsecutiveMinStep(S, smcm) \
+    (ssGetSolverInfo(S)->solverMaxConsecutiveMinStep = (smcm))
+#define rtsiGetSolverMaxConsecutiveMinStep(S) ssGetSolverInfo(S)->solverMaxConsecutiveMinStep
+
+#define rtsiSetSolverExtrapolationOrder(S, seo) ((S)->solverExtrapolationOrder = (seo))
+#define rtsiGetSolverExtrapolationOrder(S) (S)->solverExtrapolationOrder
+
+#define rtsiSetSolverNumberNewtonIterations(S, nni) ((S)->solverNumberNewtonIterations = (nni))
+#define rtsiGetSolverNumberNewtonIterations(S) (S)->solverNumberNewtonIterations
+
+#define rtsiSetSolverRefineFactor(S, smo) ((S)->solverRefineFactor = (smo))
+#define rtsiGetSolverRefineFactor(S) (S)->solverRefineFactor
+
+#define rtsiSetSolverRelTol(S, smo) ((S)->solverRelTol = (smo))
+#define rtsiGetSolverRelTol(S) (S)->solverRelTol
+
+#define rtsiSetSolverMassMatrixType(S, type) ((S)->massMatrixType = (type))
+#define rtsiGetSolverMassMatrixType(S) (S)->massMatrixType
+
+#define rtsiSetSolverMassMatrixNzMax(S, nzMax) ((S)->massMatrixNzMax = (nzMax))
+#define rtsiGetSolverMassMatrixNzMax(S) (S)->massMatrixNzMax
+
+#define rtsiSetSolverMassMatrixIr(S, ir) ((S)->massMatrixIr = (ir))
+#define rtsiGetSolverMassMatrixIr(S) (S)->massMatrixIr
+
+#define rtsiSetSolverMassMatrixJc(S, jc) ((S)->massMatrixJc = (jc))
+#define rtsiGetSolverMassMatrixJc(S) (S)->massMatrixJc
+
+#define rtsiSetSolverMassMatrixPr(S, pr) ((S)->massMatrixPr = (pr))
+#define rtsiGetSolverMassMatrixPr(S) (S)->massMatrixPr
+
+#define rtsiSetdXPtr(S, dxp) ((S)->dXPtr = (dxp))
+#define rtsiSetdX(S, dx) (*((S)->dXPtr) = (dx))
+#define rtsiGetdX(S) *((S)->dXPtr)
+
+#define rtsiSetTPtr(S, tp) ((S)->tPtr = (tp))
+#define rtsiSetT(S, t) ((*((S)->tPtr))[0] = (t))
+#define rtsiGetT(S) (*((S)->tPtr))[0]
+
+#define rtsiSetContStatesPtr(S, cp) ((S)->contStatesPtr = (cp))
+#define rtsiGetContStates(S) *((S)->contStatesPtr)
+
+#define rtsiSetNumContStatesPtr(S, cp) ((S)->numContStatesPtr = (cp))
+#define rtsiGetNumContStates(S) *((S)->numContStatesPtr)
+
+#define rtsiSetNumPeriodicContStatesPtr(S, cp) ((S)->numPeriodicContStatesPtr = (cp))
+#define rtsiGetNumPeriodicContStates(S) *((S)->numPeriodicContStatesPtr)
+
+#define rtsiSetPeriodicContStateIndicesPtr(S, cp) ((S)->periodicContStateIndicesPtr = (cp))
+#define rtsiGetPeriodicContStateIndices(S) *((S)->periodicContStateIndicesPtr)
+
+#define rtsiSetPeriodicContStateRangesPtr(S, cp) ((S)->periodicContStateRangesPtr = (cp))
+#define rtsiGetPeriodicContStateRanges(S) *((S)->periodicContStateRangesPtr)
+
+#define rtsiSetErrorStatusPtr(S, esp) ((S)->errStatusPtr = (esp))
+#define rtsiSetErrorStatus(S, es) (*((S)->errStatusPtr) = (es))
+#define rtsiGetErrorStatus(S) *((S)->errStatusPtr)
+
+#define rtsiSetModelMethodsPtr(S, mmp) ((S)->modelMethodsPtr = (mmp))
+#define rtsiGetModelMethodsPtr(S) (S)->modelMethodsPtr
+
+#define rtsiSetSolverComputingJacobian(S, val) ((S)->isComputingJacobian = (val))
+#define rtsiIsSolverComputingJacobian(S) (S)->isComputingJacobian
+
+#define rtsiSetSolverOutputComputed(S, val) ((S)->isOutputMethodComputed = (val))
+#define rtsiIsSolverOutputComputed(S) (S)->isOutputMethodComputed
+
+#define rtsiSetIsMinorTimeStepWithModeChange(S, sn) ((S)->isMinorTimeStepWithModeChange = (sn))
+#define rtsiGetIsMinorTimeStepWithModeChange(S) (S)->isMinorTimeStepWithModeChange
+
+#define rtsiIsModeUpdateTimeStep(S) \
+    (rtsiGetSimTimeStep(S) == MAJOR_TIME_STEP || rtsiGetIsMinorTimeStepWithModeChange(S))
+
+#define rtsiSetSolverZcSignalPtr(S, zcp) ((S)->zcSignalPtr = (zcp))
+#define rtsiSetSolverZcSignalVector(S, zcp) (*((S)->zcSignalPtr) = (zcp))
+#define rtsiGetSolverZcSignalVector(S) *((S)->zcSignalPtr)
+
+
+#define rtsiSetSolverZcEventsVector(S, ptr) ((S)->zcEventsVector = (ptr))
+#define rtsiGetSolverZcEventsVector(S) ((S)->zcEventsVector)
+
+#define rtsiSetSolverZcSignalAttrib(S, ptr) ((S)->zcSignalAttrib = (ptr))
+#define rtsiGetSolverZcSignalAttrib(S) ((S)->zcSignalAttrib)
+
+#define rtsiSetSolverZcSignalVectorLength(S, n) ((S)->zcSignalVectorLength = (n))
+#define rtsiGetSolverZcSignalVectorLength(S) ((S)->zcSignalVectorLength)
+
+#define rtsiSetSolverFoundContZcEvents(S, val) ((S)->foundContZcEvents = (val))
+#define rtsiGetSolverFoundContZcEvents(S) ((S)->foundContZcEvents)
+
+#endif /* !NO_FLOATS */
+
+#endif /* RTW_SOLVER_H__ */
-- 
GitLab