diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 8688e3c92..1bec35e57 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,37 +1,8 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
-    <option name="FORMATTER_TAGS_ENABLED" value="true" />
-    <JavaCodeStyleSettings>
-      <option name="ANNOTATION_PARAMETER_WRAP" value="1" />
-    </JavaCodeStyleSettings>
     <JetCodeStyleSettings>
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </JetCodeStyleSettings>
-    <ScalaCodeStyleSettings>
-      <option name="ALIGN_IN_COLUMNS_CASE_BRANCH" value="true" />
-      <option name="MULTILINE_STRING_CLOSING_QUOTES_ON_NEW_LINE" value="true" />
-    </ScalaCodeStyleSettings>
-    <codeStyleSettings language="JAVA">
-      <option name="RIGHT_MARGIN" value="150" />
-      <option name="KEEP_LINE_BREAKS" value="false" />
-      <option name="KEEP_FIRST_COLUMN_COMMENT" value="false" />
-      <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
-      <option name="ALIGN_MULTILINE_FOR" value="false" />
-      <option name="CALL_PARAMETERS_WRAP" value="1" />
-      <option name="METHOD_PARAMETERS_WRAP" value="1" />
-      <option name="METHOD_CALL_CHAIN_WRAP" value="1" />
-      <option name="BINARY_OPERATION_WRAP" value="1" />
-      <option name="ARRAY_INITIALIZER_WRAP" value="1" />
-      <option name="ASSIGNMENT_WRAP" value="1" />
-      <option name="IF_BRACE_FORCE" value="3" />
-      <option name="DOWHILE_BRACE_FORCE" value="3" />
-      <option name="WHILE_BRACE_FORCE" value="3" />
-      <option name="FOR_BRACE_FORCE" value="3" />
-      <option name="PARAMETER_ANNOTATION_WRAP" value="1" />
-      <option name="VARIABLE_ANNOTATION_WRAP" value="2" />
-      <option name="ENUM_CONSTANTS_WRAP" value="2" />
-      <option name="WRAP_ON_TYPING" value="1" />
-    </codeStyleSettings>
     <codeStyleSettings language="kotlin">
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
     </codeStyleSettings>
diff --git a/.idea/saveactions_settings.xml b/.idea/saveactions_settings.xml
deleted file mode 100644
index 3ba0ad495..000000000
--- a/.idea/saveactions_settings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="SaveActionSettings">
-    <option name="actions">
-      <set>
-        <option value="activate" />
-        <option value="organizeImports" />
-        <option value="reformat" />
-        <option value="rearrange" />
-        <option value="fieldCanBeFinal" />
-        <option value="missingOverrideAnnotation" />
-        <option value="explicitTypeCanBeDiamond" />
-        <option value="unnecessarySemicolon" />
-      </set>
-    </option>
-    <option name="configurationPath" value="" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/frameworks/builder/src/main/java/org/intocps/maestro/framework/fmi2/api/FmiBuilder.java b/frameworks/builder/src/main/java/org/intocps/maestro/framework/fmi2/api/FmiBuilder.java
index 563015fcd..e2a4a38ce 100644
--- a/frameworks/builder/src/main/java/org/intocps/maestro/framework/fmi2/api/FmiBuilder.java
+++ b/frameworks/builder/src/main/java/org/intocps/maestro/framework/fmi2/api/FmiBuilder.java
@@ -791,7 +791,7 @@ void enterInitializationMode(Scope<T> scope,boolean toleranceDefined, double tol
     }
 
     /**
-     * Interface for an fmi compoennt.
+     * Interface for an fmi component.
      * <p>
      * Note that all methods that do not take a scope uses the builders dynamic scope and adds the underlying instructions int he active scope.
      *
diff --git a/frameworks/fmi2api/src/main/java/org/intocps/maestro/framework/fmi2/api/mabl/variables/InstanceVariableFmi3Api.java b/frameworks/fmi2api/src/main/java/org/intocps/maestro/framework/fmi2/api/mabl/variables/InstanceVariableFmi3Api.java
index dd5dbf5af..6d18ae08b 100644
--- a/frameworks/fmi2api/src/main/java/org/intocps/maestro/framework/fmi2/api/mabl/variables/InstanceVariableFmi3Api.java
+++ b/frameworks/fmi2api/src/main/java/org/intocps/maestro/framework/fmi2/api/mabl/variables/InstanceVariableFmi3Api.java
@@ -219,7 +219,6 @@ private ArrayVariableFmi2Api<Object> createBuffer(PType type, String prefix, int
 
         return new ArrayVariableFmi2Api<>(var, type, scope, builder.getDynamicScope(), newAIdentifierStateDesignator(newAIdentifier(ioBufName)),
                 newAIdentifierExp(ioBufName), items);
-
     }
 
     @Override
diff --git a/interpreter/src/main/java/org/intocps/maestro/interpreter/extensions/fmi3/Fmi3Interpreter.java b/interpreter/src/main/java/org/intocps/maestro/interpreter/extensions/fmi3/Fmi3Interpreter.java
index 7f80dfbdf..3f37be9a1 100644
--- a/interpreter/src/main/java/org/intocps/maestro/interpreter/extensions/fmi3/Fmi3Interpreter.java
+++ b/interpreter/src/main/java/org/intocps/maestro/interpreter/extensions/fmi3/Fmi3Interpreter.java
@@ -46,6 +46,10 @@ public class Fmi3Interpreter {
 
     static final ExternalReflectCallHelper.ArgMapping intInArgMapper = new ExternalReflectCallHelper.ArgMapping(TP.Int, 1,
             ExternalReflectCallHelper.ArgMapping.InOut.Input, null);
+
+    static final ExternalReflectCallHelper.ArgMapping longInArgMapper = new ExternalReflectCallHelper.ArgMapping(TP.Long, 1,
+            ExternalReflectCallHelper.ArgMapping.InOut.Input, null);
+
     static final ExternalReflectCallHelper.ArgMapping doubleInArgMapper = new ExternalReflectCallHelper.ArgMapping(TP.Real, 1,
             ExternalReflectCallHelper.ArgMapping.InOut.Input, null);
 
@@ -55,6 +59,12 @@ public class Fmi3Interpreter {
     static final ExternalReflectCallHelper.ArgMapping doubleArrayInArgMapper = new ExternalReflectCallHelper.ArgMapping(TP.Real, 2,
             ExternalReflectCallHelper.ArgMapping.InOut.Input, null);
 
+    static final ExternalReflectCallHelper.ArgMapping boolArrayInArgMapper = new ExternalReflectCallHelper.ArgMapping(TP.Bool, 2,
+            ExternalReflectCallHelper.ArgMapping.InOut.Input, null);
+
+    static final ExternalReflectCallHelper.ArgMapping intArrayInArgMapper = new ExternalReflectCallHelper.ArgMapping(TP.Int, 2,
+            ExternalReflectCallHelper.ArgMapping.InOut.Input, null);
+
     static final ExternalReflectCallHelper.ArgMapping longArrayInArgMapper = new ExternalReflectCallHelper.ArgMapping(TP.Long, 2,
             ExternalReflectCallHelper.ArgMapping.InOut.Input, null);
 
@@ -301,7 +311,7 @@ public static Function<ExternalReflectCallHelper.ArgMappingContext, IArgMapping>
 
 
     private static Value getFmuInstanceValue(BufferedOutputStream fmuLogOutputStream, IFmi3Instance instance,
-            Function<String, AModuleDeclaration> resolver) throws NoSuchMethodException {
+                                             Function<String, AModuleDeclaration> resolver) throws NoSuchMethodException {
 
         //populate component functions
         var module = resolver.apply("FMI3Instance");
@@ -393,6 +403,144 @@ private static Value getFmuInstanceValue(BufferedOutputStream fmuLogOutputStream
 
         }));
 
+
+        functions.put("getOutputDerivatives", new FunctionValue.ExternalFunctionValue(fcargs -> {
+            // int getOutputDerivatives(uint valueReferences[], int nValueReferences,
+            //                      int orders[], out real values[], out int nValues);
+
+            checkArgLength(fcargs, 5);
+            try {
+                FmuResult<double[]> res = instance.getOutputDerivatives((long[]) longArrayInArgMapper.map(fcargs.get(0)),
+                        (int[]) intArrayInArgMapper.map(fcargs.get(2)));
+                doubleArrayOutArgMapper.mapOut(fcargs.get(3), res.result);
+                return status2IntValue(res.status);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
+        functions.put("getShiftDecimal", new FunctionValue.ExternalFunctionValue(fcargs->{
+            // int getShiftDecimal(uint valueReferences[], int nValueReferences, real shifts[]);
+
+            checkArgLength(fcargs, 3);
+            try {
+                FmuResult<double[]> res = instance.getShiftDecimal((long[]) longArrayInArgMapper.map(fcargs.get(0)));
+                doubleArrayOutArgMapper.mapOut(fcargs.get(2), res.result);
+                return status2IntValue(res.status);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
+        functions.put("getShiftFraction", new FunctionValue.ExternalFunctionValue(fcargs -> {
+            //  int getShiftFraction(uint valueReferences[], int nValueReferences, out uint shiftCounters[], out uint resolutions[]);
+
+            checkArgLength(fcargs, 4);
+            try {
+                FmuResult<IFmi3Instance.GetShiftFractionResponse> res = instance.getShiftFraction((long[]) longArrayInArgMapper.map(fcargs.get(0)));
+                uintArrayOutArgMapper.mapOut(fcargs.get(2), res.result.getShiftCounters());
+                uintArrayOutArgMapper.mapOut(fcargs.get(3), res.result.getResolutions());
+                return status2IntValue(res.status);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
+        functions.put("getVariableDependencies", new FunctionValue.ExternalFunctionValue(fcargs -> {
+            //  int getVariableDependencies(uint dependent, out int elementIndicesOfDependent[], out uint independents[],
+            //              out uint elementIndicesOfIndependents[], out int dependencyKinds[], int nDependencies);
+            checkArgLength(fcargs, 6);
+            try {
+                FmuResult<IFmi3Instance.VariableDependency> res = instance.getVariableDependencies((long) longInArgMapper.map(fcargs.get(0)), (long) intInArgMapper.map(fcargs.get(5)));
+                intArrayOutArgMapper.mapOut(fcargs.get(1), res.result.getElementIndicesOfDependent());
+                longArrayOutArgMapper.mapOut(fcargs.get(2), res.result.getIndependents());
+                longArrayOutArgMapper.mapOut(fcargs.get(3), res.result.getElementIndicesOfIndependents());
+                intArrayOutArgMapper.mapOut(fcargs.get(4), res.result.getDependencyKinds());
+                return status2IntValue(res.status);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
+        functions.put("setClock", new FunctionValue.ExternalFunctionValue(fcargs -> {
+//            int setClock(uint valueReferences[], int nValueReferences, bool values[]);
+            checkArgLength(fcargs, 3);
+            try {
+                Fmi3Status res = instance.setClock((long[]) longArrayInArgMapper.map(fcargs.get(0)), (boolean[]) boolArrayInArgMapper.map(fcargs.get(2)));
+                return new IntegerValue(res.value);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
+        functions.put("setContinuousStates", new FunctionValue.ExternalFunctionValue(fcargs -> {
+//            int setContinuousStates(real continuousStates[], int nContinuousStates);
+            checkArgLength(fcargs, 2);
+            try {
+                Fmi3Status res = instance.setContinuousStates((double[]) doubleArrayInArgMapper.map(fcargs.get(0)));
+                return new IntegerValue(res.value);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
+        functions.put("setIntervalDecimal", new FunctionValue.ExternalFunctionValue(fcargs -> {
+//            int setIntervalDecimal(uint valueReferences[], int nValueReferences, real interval[]);
+            checkArgLength(fcargs, 3);
+            try {
+                Fmi3Status res = instance.setIntervalDecimal((long[]) longArrayInArgMapper.map(fcargs.get(0)), (double[]) doubleArrayInArgMapper.map(fcargs.get(2)));
+                return new IntegerValue(res.value);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
+        functions.put("setIntervalFraction", new FunctionValue.ExternalFunctionValue(fcargs -> {
+//            int setIntervalFraction(uint valueReferences[], int nValueReferences, uint intervalCounter[], uint resolution[]);
+            checkArgLength(fcargs, 4);
+            try {
+                Fmi3Status res = instance.setIntervalFraction((long[]) longArrayInArgMapper.map(fcargs.get(0)),
+                        (long[]) longArrayInArgMapper.map(fcargs.get(2)), (long[]) longArrayInArgMapper.map(fcargs.get(3)));
+                return new IntegerValue(res.value);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
+        functions.put("setShiftDecimal", new FunctionValue.ExternalFunctionValue(fcargs -> {
+//            int setShiftDecimal(uint valueReferences[], int nValueReferences, real shifts[]);
+            checkArgLength(fcargs, 3);
+            Fmi3Status res = instance.setShiftDecimal((long[]) longArrayInArgMapper.map(fcargs.get(0)), (double[]) doubleArrayInArgMapper.map(fcargs.get(2)));
+            return new IntegerValue(res.value);
+        }));
+
+        functions.put("setShiftFraction", new FunctionValue.ExternalFunctionValue(fcargs -> {
+//            int setShiftFraction(uint valueReferences[], int nValueReferences, uint counters[], uint resolutions[]);
+            checkArgLength(fcargs, 4);
+            Fmi3Status res = instance.setShiftFraction((long[]) longArrayInArgMapper.map(fcargs.get(0)),
+                    (long[]) longArrayInArgMapper.map(fcargs.get(2)), (long[]) longArrayInArgMapper.map(fcargs.get(3)));
+            return new IntegerValue(res.value);
+        }));
+
+        functions.put("updateDiscreteStates", new FunctionValue.ExternalFunctionValue(fcargs -> {
+//            int updateDiscreteStates(bool[] discreteStatesNeedUpdate, bool[] terminateSimulation,
+//                    bool[] nominalsOfContinuousStatesChanged, bool[] valuesOfContinuousStatesChanged, bool[] nextEventTimeDefined,
+//                    real[] nextEventTime);
+            checkArgLength(fcargs, 6);
+            try {
+                FmuResult<IFmi3Instance.UpdateDiscreteStates> res = instance.updateDiscreteStates();
+                boolArrayOutArgMapper.mapOut(fcargs.get(0), new boolean[]{res.result.isDiscreteStatesNeedUpdate()});
+                boolArrayOutArgMapper.mapOut(fcargs.get(1), new boolean[]{res.result.isTerminateSimulation()});
+                boolArrayOutArgMapper.mapOut(fcargs.get(2), new boolean[]{res.result.isNominalsOfContinuousStatesChanged()});
+                boolArrayOutArgMapper.mapOut(fcargs.get(3), new boolean[]{res.result.isValuesOfContinuousStatesChanged()});
+                boolArrayOutArgMapper.mapOut(fcargs.get(4), new boolean[]{res.result.isNextEventTimeDefined()});
+                doubleArrayOutArgMapper.mapOut(fcargs.get(5), new double[]{res.result.getNextEventTime()});
+                return status2IntValue(res.status);
+            } catch (FmuInvocationException e) {
+                throw new InterpreterException(e);
+            }
+        }));
+
         functions.put("getClock", new FunctionValue.ExternalFunctionValue(fcargs -> {
             // int getClock(uint valueReferences[], int nValueReferences, bool values[]);
 
@@ -404,10 +552,10 @@ private static Value getFmuInstanceValue(BufferedOutputStream fmuLogOutputStream
             } catch (FmuInvocationException e) {
                 throw new InterpreterException(e);
             }
-
         }));
 
 
+
         functions.put("getContinuousStateDerivatives", new FunctionValue.ExternalFunctionValue(fcargs -> {
             //int getContinuousStateDerivatives(real derivatives[], int nContinuousStates);
 
diff --git a/maestro/outputs.csv b/maestro/outputs.csv
new file mode 100644
index 000000000..0f56a9954
--- /dev/null
+++ b/maestro/outputs.csv
@@ -0,0 +1,102 @@
+time,{x1}.controller.valve,{x2}.tank.level
+0.0,false,0.0
+0.1,false,0.1099999999999999
+0.2,false,0.19999999999999996
+0.30000000000000004,false,0.30000000000000004
+0.4,false,0.40000000000000013
+0.5,false,0.5000000000000002
+0.6,false,0.6000000000000003
+0.7,false,0.7000000000000004
+0.7999999999999999,false,0.8000000000000005
+0.8999999999999999,false,0.9000000000000006
+0.9999999999999999,false,1.0000000000000007
+1.0999999999999999,false,1.100000000000003
+1.2,false,1.2000000000000053
+1.3,false,1.3000000000000076
+1.4000000000000001,false,1.40000000000001
+1.5000000000000002,false,1.5000000000000122
+1.6000000000000003,false,1.6000000000000145
+1.7000000000000004,false,1.7000000000000168
+1.8000000000000005,false,1.8000000000000191
+1.9000000000000006,false,1.9000000000000214
+2.0000000000000004,false,2.0000000000000235
+2.1000000000000005,true,2.110000000000021
+2.2000000000000006,true,1.9902812339436071
+2.3000000000000007,true,1.879488458105753
+2.400000000000001,true,1.7801372059716003
+2.500000000000001,true,1.6910459161652158
+2.600000000000001,true,1.6111550466606475
+2.700000000000001,true,1.5395144738945912
+2.800000000000001,true,1.4752721931674422
+2.9000000000000012,true,1.4176641859492016
+3.0000000000000013,true,1.3660053335844786
+3.1000000000000014,true,1.319681269335382
+3.2000000000000015,true,1.2781410718605366
+3.3000000000000016,true,1.2408907132354772
+3.4000000000000017,true,1.2074871835932366
+3.5000000000000018,true,1.1775332225108484
+3.600000000000002,true,1.1506725944833651
+3.700000000000002,true,1.1265858522977028
+3.800000000000002,true,1.1049865379211017
+3.900000000000002,true,1.085617775722246
+4.000000000000002,true,1.0682492175090177
+4.100000000000001,true,1.0526743030509254
+4.200000000000001,true,1.0387078035062411
+4.300000000000001,true,1.0261836185383848
+4.4,true,1.014952800923189
+4.5,true,1.0048817851541365
+4.6,true,0.9958507989788068
+4.699999999999999,false,0.9877524389752776
+4.799999999999999,false,1.0859580220444744
+4.899999999999999,false,1.1859580220444768
+4.999999999999998,false,1.285958022044479
+5.099999999999998,false,1.3859580220444814
+5.1999999999999975,false,1.4859580220444837
+5.299999999999997,false,1.585958022044486
+5.399999999999997,false,1.6859580220444883
+5.4999999999999964,false,1.7859580220444906
+5.599999999999996,false,1.885958022044493
+5.699999999999996,false,1.9859580220444952
+5.799999999999995,false,2.0859580220444935
+5.899999999999995,true,2.1859580220444914
+5.999999999999995,true,2.058518842946217
+6.099999999999994,true,1.940679197716537
+6.199999999999994,true,1.8350088034505139
+6.299999999999994,true,1.7402509466819145
+6.399999999999993,true,1.6552786942194706
+6.499999999999993,true,1.5790814907920725
+6.5999999999999925,true,1.5107531407495396
+6.699999999999992,true,1.4494810308881407
+6.799999999999992,true,1.3945364662304194
+6.8999999999999915,true,1.3452660038250044
+6.999999999999991,true,1.3010836815012947
+7.099999999999991,true,1.2614640491574003
+7.19999999999999,true,1.2259359197040731
+7.29999999999999,true,1.194076765346047
+7.39999999999999,true,1.1655076925570644
+7.499999999999989,true,1.1398889359871307
+7.599999999999989,true,1.1169158177120915
+7.699999999999989,true,1.0963151237698119
+7.799999999999988,true,1.077841854889959
+7.899999999999988,true,1.0612763127745573
+7.999999999999988,true,1.0464214872771362
+8.099999999999987,true,1.0331007134067987
+8.199999999999987,true,1.0211555702924957
+8.299999999999986,true,1.0104439971203927
+8.399999999999986,true,1.0008386036375856
+8.499999999999986,true,0.9922251551294017
+8.599999999999985,false,0.9845012138524587
+8.699999999999985,false,1.0827127033139619
+8.799999999999985,false,1.1827127033139642
+8.899999999999984,false,1.2827127033139665
+8.999999999999984,false,1.3827127033139688
+9.099999999999984,false,1.482712703313971
+9.199999999999983,false,1.5827127033139734
+9.299999999999983,false,1.6827127033139757
+9.399999999999983,false,1.782712703313978
+9.499999999999982,false,1.8827127033139803
+9.599999999999982,false,1.9827127033139826
+9.699999999999982,false,2.082712703313981
+9.799999999999981,true,2.182712703313979
+9.89999999999998,true,2.0556033801068625
+9.99999999999998,true,1.9380648135073668
diff --git a/maestro/spec.mabl b/maestro/spec.mabl
new file mode 100644
index 000000000..9afcb2e30
--- /dev/null
+++ b/maestro/spec.mabl
@@ -0,0 +1,664 @@
+simulation 
+import BooleanLogic;
+import DataWriter;
+import DataWriterConfig;
+import FMI2;
+import FMI2Component;
+import Logger;
+import Math;
+import SimulationControl;
+{
+ 	int status = 0;
+	Math math = null;
+	Logger logger = null;
+	DataWriter dataWriter = null;
+	BooleanLogic booleanLogic = null;
+	@mapFmu(x1 -> "{x1}");
+	FMI2 x1 = null;
+	@mapFmu(x2 -> "{x2}");
+	FMI2 x2 = null;
+	@mapInstance(controller -> "controller");
+	FMI2Component controller = null;
+	@mapInstance(tank -> "tank");
+	FMI2Component tank = null;
+	try 
+	{
+		math = load("Math");
+		if( ((math == null)) )
+		{
+				error "math IS NULL ";
+		}
+		logger = load("Logger");
+		if( ((logger == null)) )
+		{
+				error "logger IS NULL ";
+		}
+		dataWriter = load("DataWriter");
+		if( ((dataWriter == null)) )
+		{
+				error "dataWriter IS NULL ";
+		}
+		booleanLogic = load("BooleanLogic");
+		if( ((booleanLogic == null)) )
+		{
+				error "booleanLogic IS NULL ";
+		}
+		x1 = load("FMI2", "{8c4e810f-3df3-4a00-8276-176fa3c9f000}", "file:/C:/Users/nikol/Desktop/maestro/maestro/src/test/resources/watertankcontroller-c.fmu");
+		if( ((x1 == null)) )
+		{
+				error "x1 IS NULL ";
+		}
+		x2 = load("FMI2", "{cfc65592-9ece-4563-9705-1581b6e7071c}", "file:/C:/Users/nikol/Desktop/maestro/maestro/src/test/resources/singlewatertank-20sim.fmu");
+		if( ((x2 == null)) )
+		{
+				error "x2 IS NULL ";
+		}
+		controller = x1.instantiate("controller", false, false);
+		if( ((controller == null)) )
+		{
+				error "controller IS NULL ";
+		}
+		tank = x2.instantiate("tank", false, false);
+		if( ((tank == null)) )
+		{
+				error "tank IS NULL ";
+		}
+		real STEP_SIZE = 0.1;
+		real START_TIME = 0.0;
+		real END_TIME = 10.0;
+		int FMI_OK = 0;
+		int FMI_DISCARD = 2;
+		int FMI_ERROR = 3;
+		int FMI_FATAL = 4;
+		BooleanLogic booleanLogic1;
+		try 
+		{
+			booleanLogic1 = load("BooleanLogic");
+			if( (booleanLogic1 == null) )
+			{
+					error "Failed load of: booleanLogic1";
+			}
+			real tankRealShare[1];
+			bool controllerBoolShare[1];
+			bool controllerBoolIo[4];
+			real tankRealIo[22];
+			uint tankUintVref[22];
+			real controllerRealIo[4];
+			uint controllerUintVref[4];
+			real fixed_end_time = 0.0;
+			fixed_end_time = END_TIME;
+			status = controller.setupExperiment(true, 0.1, START_TIME, true, END_TIME);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetupExperiment failed on '%s' with status: FMI_ERROR", controller);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetupExperiment failed on '%s' with status: FMI_FATAL", controller);
+					}
+					error "Failed to 'setupExperiment' on 'controller'";
+			}
+			status = tank.setupExperiment(true, 0.1, START_TIME, true, END_TIME);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetupExperiment failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetupExperiment failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setupExperiment' on 'tank'";
+			}
+			controllerUintVref[0] = 0;
+			controllerRealIo[0] = 2.0;
+			status = controller.setReal(controllerUintVref, 1, controllerRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", controller);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", controller);
+					}
+					error "Failed to 'setReal' on 'controller'";
+			}
+			controllerUintVref[0] = 1;
+			controllerRealIo[0] = 1.0;
+			status = controller.setReal(controllerUintVref, 1, controllerRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", controller);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", controller);
+					}
+					error "Failed to 'setReal' on 'controller'";
+			}
+			tankUintVref[0] = 0;
+			tankRealIo[0] = 9.0;
+			status = tank.setReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setReal' on 'tank'";
+			}
+			tankUintVref[0] = 1;
+			tankRealIo[0] = 1.0;
+			status = tank.setReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setReal' on 'tank'";
+			}
+			tankUintVref[0] = 2;
+			tankRealIo[0] = 1.0;
+			status = tank.setReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setReal' on 'tank'";
+			}
+			tankUintVref[0] = 3;
+			tankRealIo[0] = 9.81;
+			status = tank.setReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setReal' on 'tank'";
+			}
+			tankUintVref[0] = 4;
+			tankRealIo[0] = 1.0;
+			status = tank.setReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setReal' on 'tank'";
+			}
+			tankUintVref[0] = 5;
+			tankRealIo[0] = 0.0;
+			status = tank.setReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setReal' on 'tank'";
+			}
+			tankUintVref[0] = 6;
+			tankRealIo[0] = 0.0;
+			status = tank.setReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setReal' on 'tank'";
+			}
+			status = controller.enterInitializationMode();
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "EnterInitializationMode failed on '%s' with status: FMI_ERROR", controller);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "EnterInitializationMode failed on '%s' with status: FMI_FATAL", controller);
+					}
+					error "Failed to 'enterInitializationMode' on 'controller'";
+			}
+			status = tank.enterInitializationMode();
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "EnterInitializationMode failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "EnterInitializationMode failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'enterInitializationMode' on 'tank'";
+			}
+			controllerUintVref[0] = 4;
+			status = controller.getBoolean(controllerUintVref, 1, controllerBoolIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "GetBoolean failed on '%s' with status: FMI_ERROR", controller);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "GetBoolean failed on '%s' with status: FMI_FATAL", controller);
+					}
+					error "Failed to 'getBoolean' on 'controller'";
+			}
+			controllerBoolShare[0] = controllerBoolIo[0];
+			tankUintVref[0] = 16;
+			if( (controllerBoolShare[0]) )
+			{
+					tankRealIo[0] = 1.0;
+			}
+			else
+			{
+					tankRealIo[0] = 0.0;
+			}
+			status = tank.setReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'setReal' on 'tank'";
+			}
+			tankUintVref[0] = 17;
+			status = tank.getReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "GetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "GetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'getReal' on 'tank'";
+			}
+			tankRealShare[0] = tankRealIo[0];
+			controllerUintVref[0] = 3;
+			controllerRealIo[0] = tankRealShare[0];
+			status = controller.setReal(controllerUintVref, 1, controllerRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", controller);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", controller);
+					}
+					error "Failed to 'setReal' on 'controller'";
+			}
+			status = controller.exitInitializationMode();
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "ExitInitializationMode failed on '%s' with status: FMI_ERROR", controller);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "ExitInitializationMode failed on '%s' with status: FMI_FATAL", controller);
+					}
+					error "Failed to 'exitInitializationMode' on 'controller'";
+			}
+			status = tank.exitInitializationMode();
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "ExitInitializationMode failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "ExitInitializationMode failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'exitInitializationMode' on 'tank'";
+			}
+		}		finally 
+		{
+			if( (booleanLogic1 != null) )
+			{
+					unload(booleanLogic1);
+					booleanLogic1 = null;
+			}
+		}
+		BooleanLogic booleanLogic2;
+		DataWriter dataWriter1;
+		SimulationControl simulationControl;
+		try 
+		{
+			simulationControl = load("SimulationControl");
+			if( (simulationControl == null) )
+			{
+					error "Failed load of: simulationControl";
+			}
+			dataWriter1 = load("DataWriter");
+			if( (dataWriter1 == null) )
+			{
+					error "Failed load of: dataWriter1";
+			}
+			booleanLogic2 = load("BooleanLogic");
+			if( (booleanLogic2 == null) )
+			{
+					error "Failed load of: booleanLogic2";
+			}
+			bool tankCurrentTimeFullStep = true;
+			real tankCurrentTime = 0.0;
+			bool controllerCurrentTimeFullStep = true;
+			real controllerCurrentTime = 0.0;
+			real controllerRealIo[4];
+			bool controllerBoolShare[1];
+			real tankRealShare[1];
+			real tankRealIo[22];
+			uint tankUintVref[22];
+			bool controllerBoolIo[4];
+			uint controllerUintVref[4];
+			real jac_current_step_size = 0.0;
+			real jac_step_size = 0.0;
+			@TransferAs("START_TIME");
+			real jac_current_communication_point = 0.0;
+			real jac_end_time = 0.0;
+			jac_current_step_size = STEP_SIZE;
+			jac_step_size = STEP_SIZE;
+			jac_current_communication_point = START_TIME;
+			jac_end_time = END_TIME;
+			string datawriter_headers[2] = { "{x1}.controller.valve" , "{x2}.tank.level" };
+			DataWriterConfig datawriter_configuration = dataWriter1.writeHeader(datawriter_headers);
+			controllerUintVref[0] = 4;
+			status = controller.getBoolean(controllerUintVref, 1, controllerBoolIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "GetBoolean failed on '%s' with status: FMI_ERROR", controller);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "GetBoolean failed on '%s' with status: FMI_FATAL", controller);
+					}
+					error "Failed to 'getBoolean' on 'controller'";
+			}
+			tankUintVref[0] = 17;
+			status = tank.getReal(tankUintVref, 1, tankRealIo);
+			if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+			{
+					if( (status == FMI_ERROR) )
+					{
+							logger.log(4, "GetReal failed on '%s' with status: FMI_ERROR", tank);
+					}
+					if( (status == FMI_FATAL) )
+					{
+							logger.log(4, "GetReal failed on '%s' with status: FMI_FATAL", tank);
+					}
+					error "Failed to 'getReal' on 'tank'";
+			}
+			tankRealShare[0] = tankRealIo[0];
+			controllerBoolShare[0] = controllerBoolIo[0];
+			real fmu_communicationpoints[2];
+			dataWriter1.writeDataPoint(datawriter_configuration, jac_current_communication_point, controllerBoolShare[0], tankRealShare[0]);
+			bool any_discards = false;
+			while( (!true || ((jac_current_communication_point + jac_current_step_size) < jac_end_time)) )
+			{
+				bool tmp = simulationControl.stopRequested();
+				if( (tmp) )
+				{
+						error "Simulation stopped by user";
+				}
+				@Transfer();
+				controllerUintVref[0] = 3;
+				controllerRealIo[0] = tankRealShare[0];
+				status = controller.setReal(controllerUintVref, 1, controllerRealIo);
+				if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+				{
+						if( (status == FMI_ERROR) )
+						{
+								logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", controller);
+						}
+						if( (status == FMI_FATAL) )
+						{
+								logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", controller);
+						}
+						error "Failed to 'setReal' on 'controller'";
+				}
+				tankUintVref[0] = 16;
+				if( (controllerBoolShare[0]) )
+				{
+						tankRealIo[0] = 1.0;
+				}
+				else
+				{
+						tankRealIo[0] = 0.0;
+				}
+				status = tank.setReal(tankUintVref, 1, tankRealIo);
+				if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+				{
+						if( (status == FMI_ERROR) )
+						{
+								logger.log(4, "SetReal failed on '%s' with status: FMI_ERROR", tank);
+						}
+						if( (status == FMI_FATAL) )
+						{
+								logger.log(4, "SetReal failed on '%s' with status: FMI_FATAL", tank);
+						}
+						error "Failed to 'setReal' on 'tank'";
+				}
+				any_discards = false;
+				status = controller.doStep(jac_current_communication_point, jac_current_step_size, false);
+				if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+				{
+						if( (status == FMI_ERROR) )
+						{
+								logger.log(4, "DoStep failed on '%s' with status: FMI_ERROR", controller);
+						}
+						if( (status == FMI_FATAL) )
+						{
+								logger.log(4, "DoStep failed on '%s' with status: FMI_FATAL", controller);
+						}
+						error "Failed to 'doStep' on 'controller'";
+				}
+				if( (status != FMI_OK) )
+				{
+						if( (status == FMI_DISCARD) )
+						{
+								status = controller.getRealStatus(2, ref controllerCurrentTime);
+								controllerCurrentTimeFullStep = false;
+						}
+				}
+				else
+				{
+						controllerCurrentTime = jac_current_communication_point + jac_current_step_size;
+						controllerCurrentTimeFullStep = true;
+				}
+				fmu_communicationpoints[0] = controllerCurrentTime;
+				if( (!controllerCurrentTimeFullStep) )
+				{
+						logger.log(1, "## FMU: '%s' DISCARDED step at sim-time: %f for step-size: %f and proposed sim-time: %.15f", "controller", jac_current_communication_point, jac_current_step_size, controllerCurrentTime);
+						any_discards = any_discards || !controllerCurrentTimeFullStep;
+				}
+				status = tank.doStep(jac_current_communication_point, jac_current_step_size, false);
+				if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+				{
+						if( (status == FMI_ERROR) )
+						{
+								logger.log(4, "DoStep failed on '%s' with status: FMI_ERROR", tank);
+						}
+						if( (status == FMI_FATAL) )
+						{
+								logger.log(4, "DoStep failed on '%s' with status: FMI_FATAL", tank);
+						}
+						error "Failed to 'doStep' on 'tank'";
+				}
+				if( (status != FMI_OK) )
+				{
+						if( (status == FMI_DISCARD) )
+						{
+								status = tank.getRealStatus(2, ref tankCurrentTime);
+								tankCurrentTimeFullStep = false;
+						}
+				}
+				else
+				{
+						tankCurrentTime = jac_current_communication_point + jac_current_step_size;
+						tankCurrentTimeFullStep = true;
+				}
+				fmu_communicationpoints[1] = tankCurrentTime;
+				if( (!tankCurrentTimeFullStep) )
+				{
+						logger.log(1, "## FMU: '%s' DISCARDED step at sim-time: %f for step-size: %f and proposed sim-time: %.15f", "tank", jac_current_communication_point, jac_current_step_size, tankCurrentTime);
+						any_discards = any_discards || !tankCurrentTimeFullStep;
+				}
+				tankUintVref[0] = 17;
+				status = tank.getReal(tankUintVref, 1, tankRealIo);
+				if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+				{
+						if( (status == FMI_ERROR) )
+						{
+								logger.log(4, "GetReal failed on '%s' with status: FMI_ERROR", tank);
+						}
+						if( (status == FMI_FATAL) )
+						{
+								logger.log(4, "GetReal failed on '%s' with status: FMI_FATAL", tank);
+						}
+						error "Failed to 'getReal' on 'tank'";
+				}
+				controllerUintVref[0] = 4;
+				status = controller.getBoolean(controllerUintVref, 1, controllerBoolIo);
+				if( ((status == FMI_ERROR) || (status == FMI_FATAL)) )
+				{
+						if( (status == FMI_ERROR) )
+						{
+								logger.log(4, "GetBoolean failed on '%s' with status: FMI_ERROR", controller);
+						}
+						if( (status == FMI_FATAL) )
+						{
+								logger.log(4, "GetBoolean failed on '%s' with status: FMI_FATAL", controller);
+						}
+						error "Failed to 'getBoolean' on 'controller'";
+				}
+				tankRealShare[0] = tankRealIo[0];
+				controllerBoolShare[0] = controllerBoolIo[0];
+				if( (!any_discards) )
+				{
+						jac_current_communication_point = jac_current_communication_point + jac_current_step_size;
+						dataWriter1.writeDataPoint(datawriter_configuration, jac_current_communication_point, controllerBoolShare[0], tankRealShare[0]);
+						jac_current_step_size = jac_step_size;
+				}
+			}
+			dataWriter1.close();
+		}		finally 
+		{
+			if( (simulationControl != null) )
+			{
+					unload(simulationControl);
+					simulationControl = null;
+			}
+			if( (dataWriter1 != null) )
+			{
+					unload(dataWriter1);
+					dataWriter1 = null;
+			}
+			if( (booleanLogic2 != null) )
+			{
+					unload(booleanLogic2);
+					booleanLogic2 = null;
+			}
+		}
+		controller.terminate();
+		tank.terminate();
+	}	finally 
+	{
+		if( ((controller != null)) )
+		{
+				x1.freeInstance(controller);
+				controller = null;
+		}
+		if( ((tank != null)) )
+		{
+				x2.freeInstance(tank);
+				tank = null;
+		}
+		if( ((x1 != null)) )
+		{
+				unload(x1);
+				x1 = null;
+		}
+		if( ((x2 != null)) )
+		{
+				unload(x2);
+				x2 = null;
+		}
+		if( ((math != null)) )
+		{
+				unload(math);
+				math = null;
+		}
+		if( ((logger != null)) )
+		{
+				unload(logger);
+				logger = null;
+		}
+		if( ((dataWriter != null)) )
+		{
+				unload(dataWriter);
+				dataWriter = null;
+		}
+		if( ((booleanLogic != null)) )
+		{
+				unload(booleanLogic);
+				booleanLogic = null;
+		}
+	}
+}
\ No newline at end of file
diff --git a/maestro/spec.runtime.json b/maestro/spec.runtime.json
new file mode 100644
index 000000000..b27618b3b
--- /dev/null
+++ b/maestro/spec.runtime.json
@@ -0,0 +1,10 @@
+{
+  "environment_variables" : {
+    "{x1}.controller.maxLevel" : 2,
+    "{x1}.controller.minLevel" : 4
+  },
+  "DataWriter" : [ {
+    "filename" : "outputs.csv",
+    "type" : "CSV"
+  } ]
+}
\ No newline at end of file
diff --git a/typechecker/src/main/resources/org/intocps/maestro/typechecker/FMI3.mabl b/typechecker/src/main/resources/org/intocps/maestro/typechecker/FMI3.mabl
index 657f40d04..cc552755b 100644
--- a/typechecker/src/main/resources/org/intocps/maestro/typechecker/FMI3.mabl
+++ b/typechecker/src/main/resources/org/intocps/maestro/typechecker/FMI3.mabl
@@ -117,8 +117,8 @@ module FMI3Instance import FMU3State;{
         /* end::getNumberOfVariableDependencies[] */
     
         /* tag::getVariableDependencies[] */
-        int getVariableDependencies(uint dependent, int elementIndicesOfDependent[], uint independents[],
-                uint elementIndicesOfIndependents[], int dependencyKinds[], int nDependencies);
+        int getVariableDependencies(uint dependent, out int elementIndicesOfDependent[], out uint independents[],
+                out uint elementIndicesOfIndependents[], out int dependencyKinds[], int nDependencies);
         /* end::getVariableDependencies[] */
     
         /* getting and setting the internal FMU state */
@@ -191,7 +191,7 @@ module FMI3Instance import FMU3State;{
         /* end::getShiftDecimal[] */
     
         /* tag::getShiftFraction[] */
-        int getShiftFraction(uint valueReferences[], int nValueReferences, uint shiftCounters[], uint resolutions[]);
+        int getShiftFraction(uint valueReferences[], int nValueReferences, out uint shiftCounters[], out uint resolutions[]);
         /* end::getShiftFraction[] */
     
         /* tag::setIntervalDecimal[] */
@@ -279,7 +279,7 @@ module FMI3Instance import FMU3State;{
         /* end::EnterStepMode[] */
     
         /* tag::getOutputDerivatives[] */
-        int getOutputDerivatives(uint valueReferences[], int nValueReferences, int orders[], real values[], int nValues);
+        int getOutputDerivatives(uint valueReferences[], int nValueReferences, int orders[], out real values[], out int nValues);
         /* end::getOutputDerivatives[] */
     
         /* tag::DoStep[] */