diff --git a/FMI/import/include/fmuWrapper.h b/FMI/import/include/fmuWrapper.h
deleted file mode 100644
index c0a2adb026a..00000000000
--- a/FMI/import/include/fmuWrapper.h
+++ /dev/null
@@ -1,155 +0,0 @@
-#ifndef FMUWRAPPER_H
-#define FMUWRAPPER_H
-#endif
-
-#include "fmiModelFunctions.h"
-#include "xml_parser.h"
-#define COMBINENAME(a,b) a##_##b
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-// typedef of function pointers to FMI interface functions       
-typedef const char* (*fGetModelTypesPlatform)();
-typedef const char* (*fGetVersion)();
-typedef fmiComponent (*fInstantiateModel)(fmiString instanceName, fmiString GUID,
-                                        fmiCallbackFunctions functions, fmiBoolean loggingOn);
-typedef void      (*fFreeModelInstance)  (fmiComponent c);
-typedef fmiStatus (*fSetDebugLogging)    (fmiComponent c, fmiBoolean loggingOn);
-typedef fmiStatus (*fSetTime)            (fmiComponent c, fmiReal time);
-typedef fmiStatus (*fSetContinuousStates)(fmiComponent c, const fmiReal x[], size_t nx);
-typedef fmiStatus (*fCompletedIntegratorStep)(fmiComponent c, fmiBoolean* callEventUpdate);
-typedef fmiStatus (*fSetReal)   (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiReal    value[]);
-typedef fmiStatus (*fSetInteger)(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiInteger value[]);
-typedef fmiStatus (*fSetBoolean)(fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiBoolean value[]);
-typedef fmiStatus (*fSetString) (fmiComponent c, const fmiValueReference vr[], size_t nvr, const fmiString  value[]);
-typedef fmiStatus (*fInitialize)(fmiComponent c, fmiBoolean toleranceControlled, 
-                               fmiReal relativeTolerance, fmiEventInfo* eventInfo);
-typedef fmiStatus (*fGetDerivatives)    (fmiComponent c, fmiReal derivatives[]    , size_t nx);
-typedef fmiStatus (*fGetEventIndicators)(fmiComponent c, fmiReal eventIndicators[], size_t ni);
-typedef fmiStatus (*fGetReal)   (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiReal    value[]);
-typedef fmiStatus (*fGetInteger)(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiInteger value[]);
-typedef fmiStatus (*fGetBoolean)(fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiBoolean value[]);
-typedef fmiStatus (*fGetString) (fmiComponent c, const fmiValueReference vr[], size_t nvr, fmiString  value[]);
-typedef fmiStatus (*fEventUpdate)               (fmiComponent c, fmiBoolean intermediateResults, fmiEventInfo* eventInfo);
-typedef fmiStatus (*fGetContinuousStates)       (fmiComponent c, fmiReal states[], size_t nx);
-typedef fmiStatus (*fGetNominalContinuousStates)(fmiComponent c, fmiReal x_nominal[], size_t nx);
-typedef fmiStatus (*fGetStateValueReferences)   (fmiComponent c, fmiValueReference vrx[], size_t nx);
-typedef fmiStatus (*fTerminate)                 (fmiComponent c);
-
-// typedef of the data structure FMI containing loaded FMI functions
-typedef struct {
-    ModelDescription* modelDescription;
-    HINSTANCE dllHandle;
-    fGetModelTypesPlatform getModelTypesPlatform;
-    fGetVersion getVersion;
-    fInstantiateModel instantiateModel;
-    fFreeModelInstance freeModelInstance;
-    fSetDebugLogging setDebugLogging;
-    fSetTime setTime;
-    fSetContinuousStates setContinuousStates;
-    fCompletedIntegratorStep completedIntegratorStep;
-    fSetReal setReal;
-    fSetInteger setInteger;
-    fSetBoolean setBoolean;
-    fSetString setString;
-    fInitialize initialize;
-    fGetDerivatives getDerivatives;
-    fGetEventIndicators getEventIndicators;
-    fGetReal getReal;
-    fGetInteger getInteger;
-    fGetBoolean getBoolean;
-    fGetString getString;
-    fEventUpdate eventUpdate;
-    fGetContinuousStates getContinuousStates;
-    fGetNominalContinuousStates getNominalContinuousStates;
-    fGetStateValueReferences getStateValueReferences;
-    fTerminate terminate;
-	int flagInit;
-} FMI;
-
-#ifdef _DEBUG__
-typedef enum {
-    modelInstantiated = 1<<0,
-    modelInitialized  = 1<<1,
-    modelTerminated   = 1<<2,
-    modelError        = 1<<3
-} ModelState;
-
-typedef struct {
-    fmiReal    *r;
-    fmiInteger *i;
-    fmiBoolean *b;
-    fmiString  *s;
-    fmiBoolean *isPositive;
-    fmiReal time;
-    fmiString instanceName;
-    fmiString GUID;
-    fmiCallbackFunctions functions;
-    fmiBoolean loggingOn;
-    ModelState state;
-} ModelInstance;
-
-#endif
-
-void PrintModelStates(void* in_fmu, double in_time);
-const char* fmiGetModelTypesPF(void* in_fmi);
-const char* fmiGetVer(void* in_fmi);
-static void* getProAdr(FMI* fmi, const char* mid, const char* funName);
-void* loadFMUDll(void* in_fmi, const char* pathFMUDll,const char* mid);
-void freeFMUDll(void* dummy);
-void fmiSetDebugLog(void* in_fmi, void* in_fmu, char log);
-void fmiSetT(void* in_fmi, void* in_fmu, double in_t);
-void fmiSetContStates(void* in_fmi, void* in_fmu, const double* in_x, int nx);
-void fmiSetRealVR(void* in_fmi, void* in_fmu, const int* in_vr, const double* rv, int nvr);
-void fmiSetIntegerVR(void* in_fmi, void* in_fmu, const int* in_vr, const int* iv, int nvr);
-void fmiSetStringVR(void* in_fmi, void* in_fmu, const int* in_vr, const char** sv, int nvr);
-void fmiSetBooleanVR(void* in_fmi, void* in_fmu, const int* in_vr, const char* in_bv, int nvr);
-void fmiCompIntStep(void* in_fmi, void* in_fmu, void* in_stepEvt);
-void fmiGetContStates(void* in_fmi, void* in_fmu, double* out_x, int nx);
-void fmiGetNomContStates(void* in_fmi, void* in_fmu, double* x_nom, int nx);
-void fmiGetStateVR(void* in_fmi, void* in_fmu, int* in_vrx, int nx);
-void fmiGetDer(void* in_fmi, void* in_fmu, double* der_x, int nx, const double* x);
-void fmiGetRealVR(void* in_fmi, void* in_fmu, const int* in_vr, double* rv, int nvr);
-void fmiGetIntegerVR(void* in_fmi, void* in_fmu, const int* in_vr, int* iv, int nvr);
-void fmiGetStringVR(void* in_fmi, void* in_fmu, const int* in_vr, const char** sv, int nvr);
-void fmiGetBooleanVR(void* in_fmi, void* in_fmu, const int* in_vr, char* bv, int nvr);
-void fmiGetTimeEvent(void * in_evtInfo, double in_time, double in_pretime, void * in_timeEvt, double* out_nextTime);
-void fmiGetEventInd(void* in_fmi, void* in_fmu, double* z, int ni);
-void fmuStateEventCheck(void* stateEvt, int ni, const double* z, const double* prez);
-void fmiEvtUpdate(void* in_fmi, void* in_fmu,fmiBoolean inter_res, fmiEventInfo* in_evtInfo);
-void fmuEventUpdate(void * in_fmufun, void * in_inst, void * in_evtInfo, void * timeEvt, void * stepEvt, void * stateEvt, void * interMediateRes, double x, double* flag);
-void fmuLogger(void* in_fmu, const char* instanceName, fmiStatus status,const char* category, const char* message, ...);
-void* fmiInstantiate(void* in_fmi, const char* instanceName,  const char* GUID, void* in_functions, int logFlag);
-void fmiInit(void* in_fmi, void* in_fmu, int tolCont, double rTol, void* in_evtInfo);
-void fmiTerminator(void* in_fmi, void* in_fmu);
-void* instantiateFMIFun(const char* mid, const char* pathFMUDll);
-void freeFMIFun(void* in_fmi);
-void* fmuBooleanInst(int def_bool);
-void freefmuBooleanInst(void* in_bool);
-void fmiFreeModelInst(void* in_fmu);
-void* fmiCallbackFuns();
-void fmiFreeCallbackFuns(void * functions);
-void* fmiEvtInfo();
-void freefmiEvtInfo(void* in_evtInfo);
-void printVariables(const double * var, int n, const char* varName);
-void printIntVariables(const int * var, int n, const char* varName);
-
-// void* fmiInstantiate(void* in_fmi, const char* instanceName,  const char* GUID, void* in_functions, int logFlag);
-// void fmiSetT(void* in_fmi, void* in_fmu, double t);
-// void fmiGetContStates(void * /*_fmufun*/, void * /*_in_inst*/, double * /*_in_x*/, int);
-// void fmiGetDer(void* in_fmi, void* in_fmu, double* der_x, int nx, const double* x);
-// void* instantiateFMIFun(const char* mid, const char* pathFMUDll);
-// void fmiCompIntStep(void* in_fmi, void* in_fmu, void* in_stepEvt);
-// void freeFMIfun(void* in_fmi);
-// void printVariables(const double * /*_var*/, int /*_n*/, const char* /*_varName*/);
-// // void fmiFreeModelInst(void* in_fmi, void* in_fmu);
-// void fmiFreeModelInst(void* in_fmu);
-// void fmiGetTimeEvent(void * /*_in_evtInfo*/, double /*_in_time*/, double /*_in_pretime*/, void * /*_in_timeEvt*/, double* /*_out_nextTime*/);
-// void fmuStateEventCheck(void * /*_stateEvt*/, int /*_ni*/, const double * /*_z*/, const double * /*_prez*/);
-// //signed char fmuStateEventCheck(void * /*_stateEvt*/, int /*_ni*/, const double * /*_z*/, const double * /*_prez*/);
-// void fmuEventUpdate(void * /*_in_fmufun*/, void * /*_in_inst*/, void * /*_in_evtInfo*/, void * /*_timeEvt*/, void * /*_stepEvt*/, void * /*_stateEvt*/, void * /*_interMediateRes*/, double, double*);
-#ifdef __cplusplus
-} //extern "C"
-#endif
diff --git a/FMI/import/include/moGenerator.h b/FMI/import/include/moGenerator.h
deleted file mode 100644
index 9d648e70815..00000000000
--- a/FMI/import/include/moGenerator.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <windows.h>
-#include "xml_parser.h"
-#include "fmuWrapper.h"
-
-static char* getDecompPath(const char * omPath, const char* mid);
-static char* getDllPath(const char* decompPath,const char* mid);
-static char* getXMLfile(const char * decompPath, const char * modeldes);
-static int decompress(const char* fmuPath, const char* decompPath);
-static char* getFMUname(const char* fmupath);
-void tmpcodegen(size_t , size_t , const char* , const char*, const char* );
-void blockcodegen(ModelDescription*, size_t , size_t , const char* , const char* , const char* , const char* );
diff --git a/FMI/import/include/stack.h b/FMI/import/include/stack.h
deleted file mode 100644
index b45cd31c467..00000000000
--- a/FMI/import/include/stack.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* ------------------------------------------------------------------------- 
- * stack.c
- * A stack of pointers. 
- * Copyright 2010 QTronic GmbH. All rights reserved. 
- * Modified for OpenModelica Project
- * -------------------------------------------------------------------------*/ 
-
-#ifndef STACK_H
-#define STACK_H
-
-typedef struct {
-    void** stack;
-    int stackSize;    // allocated size of stack
-    int stackPos;     // array index of top element, -1 if stack is empty.
-    int initialSize;  // how many element to allocate initially
-    int inc;          // how many elements to allocate when stack gets full
-} Stack;
-
-Stack* stackNew(int initialSize, int inc);
-int stackIsEmpty(Stack* s);
-int stackPush(Stack* s, void* e);
-void* stackPeek(Stack* s);
-void* stackPop(Stack* s);
-void** stackPopAllAsArray(Stack* s, int *size);
-void** stackLastPopedAsArray0(Stack* s, int n);
-void stackFree(Stack* s);
-
-#endif // STACK_H
-
diff --git a/FMI/import/include/xml_parser.h b/FMI/import/include/xml_parser.h
deleted file mode 100644
index c24a637056d..00000000000
--- a/FMI/import/include/xml_parser.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/* ------------------------------------------------------------------------- 
- * xml_parser.h
- * A parser for file modelVariables.xml of an FMU.
- * Copyright 2010 QTronic GmbH. All rights reserved.
- * Modified for OpenModelica Project
- * -------------------------------------------------------------------------*/
-
-#ifndef xml_parser_h
-#define xml_parser_h
-
-// define XML_STATIC before including expat.h
-// to prevent error when linking with libexpatMT.lib
-#define XML_STATIC 
-#include <expat.h>
-#include <fmiModelTypes.h>
-#include "stack.h"
-
-#define SIZEOF_ELM 25
-extern const char *elmNames[SIZEOF_ELM];
-
-#define SIZEOF_ATT 34
-extern const char *attNames[SIZEOF_ATT];
-
-#define SIZEOF_ENU 13
-extern const char *enuNames[SIZEOF_ENU];
-
-// Attributes
-typedef enum {
-    elm_fmiModelDescription,elm_UnitDefinitions,elm_BaseUnit,elm_DisplayUnitDefinition,elm_TypeDefinitions,
-    elm_Type,elm_RealType,elm_IntegerType,elm_BooleanType,elm_StringType,elm_EnumerationType,elm_Item,
-    elm_DefaultExperiment,elm_VendorAnnotations,elm_Tool,elm_Annotation,elm_ModelVariables,elm_ScalarVariable,
-    elm_DirectDependency,elm_Name,elm_Real,elm_Integer,elm_Boolean,elm_String,elm_Enumeration
-} Elm;
-
-// Attributes
-typedef enum { 
-  att_fmiVersion,att_displayUnit,att_gain,att_offset,att_unit,att_name,att_description,att_quantity,att_relativeQuantity,
-  att_min,att_max,att_nominal,att_declaredType,att_start,att_fixed,att_startTime,att_stopTime,att_tolerance,att_value,
-  att_valueReference,att_variability,att_causality,att_alias,att_modelName,att_modelIdentifier,att_guid,att_author,
-  att_version,att_generationTool,att_generationDateAndTime,att_variableNamingConvention,att_numberOfContinuousStates,
-  att_numberOfEventIndicators,att_input
-} Att;
-
-// Enumeration values
-typedef enum {
-    enu_flat,enu_structured,enu_constant,enu_parameter,enu_discrete,enu_continuous,
-    enu_input,enu_output,enu_internal,enu_none,enu_noAlias,enu_alias,enu_negatedAlias    
-} Enu;
-
-// AST node for element 
-// DisplayUnitDefinition, RealType, IntegerType, BooleanType, StringType
-// DefaultExperiment, Item, Annotation, Name, Real, Integer, Boolean, String, Enumeration
-typedef struct {
-    Elm type;          // element type 
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, even number
-} Element;
-
-// AST node for element that has a list of elements 
-// BaseUnit, EnumerationType, Tool, DirectDependency
-typedef struct {
-    Elm type;          // element type 
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, even number
-    Element** list;    // null-terminated array of pointers to elements, not null
-} ListElement;
-
-// AST node for element Type
-typedef struct {
-    Elm type;          // element type 
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, an even number
-    Element* typeSpec; // one of RealType, IntegerType etc. 
-} Type;
-
-// AST node for element ScalarVariable
-typedef struct {
-    Elm type;          // element type 
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, even number
-    Element* typeSpec; // one of Real, Integer, etc
-    Element** directDependencies; // null or null-terminated list of Name
-} ScalarVariable;
-
-// AST node for element ModelDescription
-typedef struct {
-    Elm type;          // element type
-    const char** attributes; // null or n attribute value strings
-    int n;             // size of attributes, even number
-    ListElement** unitDefinitions;    // NULL or null-terminated list of BaseUnits
-    Type**        typeDefinitions;    // NULL or null-terminated list of Types 
-    Element*      defaultExperiment;  // NULL or DefaultExperiment
-    ListElement** vendorAnnotations;  // NULL or null-terminated list of Tools
-    ScalarVariable** modelVariables;  // NULL or null-terminated list of ScalarVariable
-} ModelDescription;
-
-// types of AST nodes used to represent an element
-typedef enum { 
-    astElement, 
-    astListElement,
-    astType,
-    astScalarVariable,
-    astModelDescription
-} AstNodeType;
-
-// Possible results when retrieving an attribute value from an element
-typedef enum { 
-    valueMissing,
-    valueDefined,
-    valueIllegal
-} ValueStatus;
-
-// Public methods: Parsing and low-level AST access
-ModelDescription* parse(const char* xmlPath);
-const char* getString(void* element, Att a);
-double getDouble     (void* element, Att a, ValueStatus* vs);
-int getInt           (void* element, Att a, ValueStatus* vs);
-unsigned int getUInt (void* element, Att a, ValueStatus* vs);
-char getBoolean      (void* element, Att a, ValueStatus* vs);
-Enu getEnumValue     (void* element, Att a, ValueStatus* vs);
-void freeElement     (void* element);
-
-// Convenience methods for AST access. To be used afer successful validation only.
-const char* getModelIdentifier(ModelDescription* md);
-int getNumberOfStates(ModelDescription* md);
-int getNumberOfEventIndicators(ModelDescription* md);
-const char* getName(void* element);
-Enu getCausality(void* scalarVariable);
-Enu getVariability(void* scalarVariable);
-Enu getAlias(void* scalarVariable);
-fmiValueReference getValueReference(void* scalarVariable);
-ScalarVariable* getVariableByName(ModelDescription* md, const char* name);
-ScalarVariable* getVariable(ModelDescription* md, fmiValueReference vr, Elm type);
-Type* getDeclaredType(ModelDescription* md, const char* declaredType);
-const char* getString2(ModelDescription* md, void* sv, Att a);
-const char * getDescription(ModelDescription* md, ScalarVariable* sv);
-const char * getVariableAttributeString(ModelDescription* md, fmiValueReference vr, Elm type, Att a);
-double getVariableAttributeDouble(ModelDescription* md, fmiValueReference vr, Elm type, Att a, ValueStatus* vs);
-double getNominal(ModelDescription* md, fmiValueReference vr);
-
-#endif // xml_parser_h
-
diff --git a/FMI/import/source/fmuModelica.tmp b/FMI/import/source/fmuModelica.tmp
deleted file mode 100644
index 4bf05ea8e11..00000000000
--- a/FMI/import/source/fmuModelica.tmp
+++ /dev/null
@@ -1,279 +0,0 @@
-class fmuModelInst
-    extends ExternalObject;
-    function constructor
-      input fmuFunctions in_fmufun;
-      input String in_instName;
-      input String guid;
-      input fmuCallbackFuns functions;
-      input Boolean logFlag;
-      output fmuModelInst inst;
-      external "C" inst = fmiInstantiate(in_fmufun,in_instName,guid,functions,logFlag)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o");
-    end constructor;
-    function destructor
-      input fmuModelInst inst;
-      external "C" fmiFreeModelInst(inst)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-    end destructor;
-  end fmuModelInst;
-  
-  class fmuLoadDll "load dll from FMU"
-    extends ExternalObject;
-    function constructor
-      input fmuFunctions in_fmufun;
-      input String in_dllPath;
-      output fmuLoadDll dummy;
-      external "C" dummy = loadFMUDll(in_fmufun,in_dllPath)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o");
-    end constructor;
-    function destructor
-      external "C" freeFMUDll()       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-    end destructor;
-  end fmuLoadDll;
-  
-  class fmuFunctions "List of interface functions defined in FMI 1.0"
-    extends ExternalObject;
-    function constructor
-	  input String mid;
-      input String dllPath;
-      output fmuFunctions fmufun;
-      external "C" fmufun = instantiateFMIFun(mid,dllPath)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o");
-    end constructor;
-    function destructor
-      input fmuFunctions fmufun;
-      external "C" freeFMIFun(fmufun)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-    end destructor;
-  end fmuFunctions;
-  
-  class fmuCallbackFuns "Construct for callbacks defined in FMU"
-    extends ExternalObject;
-    function constructor
-      output fmuCallbackFuns functions;
-      external "C" functions = fmiCallbackFuns()       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o");
-    end constructor;
-    function destructor
-      input fmuCallbackFuns functions;
-      external "C" fmiFreeCallbackFuns(functions)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-    end destructor;
-  end fmuCallbackFuns;
-  
-  function fmuSetTime
-    input fmuFunctions fmufun;
-    input fmuModelInst inst;
-    input Real in_time;
-    external "C" fmiSetT(fmufun,inst,in_time)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuSetTime;
-  
-  function fmuSetContStates "set values of continuous states"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer nx;
-    input Real x[nx];
-    external "C" fmiSetContStates(fmufun,in_inst,x,nx)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuSetContStates;
-  
-  function fmuSetRealVR "set values of real variables via value references"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer nr;
-    input Integer in_vr[nr];
-    input Real in_rv[nr];
-    external "C" fmiSetRealVR(fmufun,in_inst,in_vr,in_rv,nr)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuSetRealVR;
-  
-  function fmuSetIntegerVR "set values of integer variables via value references"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer ni;
-    input Integer in_vr[ni];
-    input Integer in_iv[ni];
-    external "C" fmiSetIntegerVR(fmufun,in_inst,in_vr,in_iv,ni)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuSetIntegerVR;
-  
-  function fmuSetStringVR "set values of string variables via value references"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer ns;
-    input Integer in_vr[ns];
-    input String in_sv[ns];
-    external "C" fmiSetStringVR(fmufun,in_inst,in_vr,in_sv,ns)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuSetStringVR;
-  
-  function fmuSetBooleanVR "set values of boolean variables via value references"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer nb;
-    input Integer in_vr[nb];
-    input Boolean in_bv[nb];
-    external "C" fmiSetBooleanVR(fmufun,in_inst,in_vr,in_bv,nb)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuSetBooleanVR;
-  
-  function fmuGetContStates "get values of continuous states"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer nx;
-    output Real in_x[nx];
-    external "C" fmiGetContStates(fmufun,in_inst,in_x,nx)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuGetContStates;
-  
-  function fmuGetRealVR "get values of real variables via value references"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer nr;
-    input Integer in_vr[nr];
-    output Real rv[nr];
-    external "C" fmiGetRealVR(fmufun,in_inst,in_vr,rv,nr)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuGetRealVR;
-  
-  function fmuGetIntegerVR "get values of integer variables via value references"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer ni;
-    input Integer in_vr[ni];
-    output Integer iv[ni];
-    external "C" fmiGetIntegerVR(fmufun,in_inst,in_vr,iv,ni)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuGetIntegerVR;
-  
-  function fmuGetStringVR "get values of string variables via value references"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer ns;
-    input Integer in_vr[ns];
-    output String sv[ns];
-    external "C" fmiGetStringVR(fmufun,in_inst,in_vr,sv,ns)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuGetStringVR;
-  
-  function fmuGetBooleanVR "get values of boolean variables via value references"
-    input fmuFunctions fmufun;
-    input fmuModelInst in_inst;
-	input Integer nb;
-    input Integer in_vr[nb];
-    output Boolean bv[nb];
-    external "C" fmiGetBooleanVR(fmufun,in_inst,in_vr,bv,nb)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuGetBooleanVR;
-  
-  function fmuGetDer "function to calculate the derivatives"
-    input fmuFunctions fmufun;
-    input fmuModelInst inst;
-	input Integer nx;
-    input Real x[nx];
-    output Real der_x_out[nx];
-    external "C" fmiGetDer(fmufun,inst,der_x_out,nx,x)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuGetDer;
-  
-  class fmuEventInfo
-    extends ExternalObject;
-    function constructor
-      output fmuEventInfo evtInfo;
-      external "C" evtInfo = fmiEvtInfo()       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o");
-    end constructor;
-    function destructor
-      input fmuEventInfo evtInfo;
-      external "C" freefmiEvtInfo(evtInfo)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-    end destructor;
-  end fmuEventInfo;
-  
-  class fmuBoolean
-    extends ExternalObject;
-    function constructor
-      input Integer default;
-      output fmuBoolean fmuBool;
-      external "C" fmuBool = fmuBooleanInst(default)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o");
-    end constructor;
-    function destructor
-      input fmuBoolean in_bool;
-      external "C" freefmuBooleanInst(in_bool)       annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-    end destructor;
-  end fmuBoolean;
-  
-  function fmuInit
-    input fmuFunctions fmufun;
-    input fmuModelInst inst;
-    input Boolean tolControl;
-    input Real relTol;
-    input fmuEventInfo evtInfo;
-    external "C" fmiInit(fmufun,inst,tolControl,relTol,evtInfo)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuInit;
-  
-  function fmuCompIntStep
-    input fmuFunctions fmufun;
-    input fmuModelInst inst;
-    input fmuBoolean stepEvt;
-    external "C" fmiCompIntStep(fmufun,inst,stepEvt)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuCompIntStep;
-  
-  function fmuGetTimeEvt
-    input fmuEventInfo in_evtInfo;
-    input Real in_time;
-    input Real in_pretime;
-    input fmuBoolean in_timeEvt;
-    output Real out_nextTime;
-    external "C" fmiGetTimeEvent(in_evtInfo,in_time,in_pretime,in_timeEvt,out_nextTime)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuGetTimeEvt;
-  
-  function fmuGetEventInd
-    input fmuFunctions fmufun;
-    input fmuModelInst inst;
-    input Integer nz;
-    output Real z[nz];
-    external "C" fmiGetEventInd(fmufun,inst,z,nz)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuGetEventInd;
-  
-  function fmuStateEvtCheck
-    input fmuBoolean stateEvt;
-    input Integer nz;
-    input Real z[nz];
-    input Real prez[nz];
-    external "C" fmuStateEventCheck(stateEvt,nz,z,prez)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuStateEvtCheck;
-  
-  function fmuEvtUpdate
-    input fmuFunctions in_fmufun;
-    input fmuModelInst in_inst;
-    input fmuEventInfo in_evtInfo;
-    input fmuBoolean timeEvt;
-    input fmuBoolean stepEvt;
-    input fmuBoolean stateEvt;
-    input fmuBoolean interMediateRes;
-    input Real x;
-    output Real flag;
-    external "C" fmuEventUpdate(in_fmufun,in_inst,in_evtInfo,timeEvt,stepEvt,stateEvt,interMediateRes,x,flag)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end fmuEvtUpdate;
-  
-  function PrintState
-    input fmuModelInst in_fmu;
-    input Real in_time;
-    external "C" PrintModelStates(in_fmu,in_time)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end PrintState;
-  
-  function printVariable
-    input Real var[:];
-    input Integer n;
-    input String varName;
-    external "C" printVariables(var,n,varName)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end printVariable;
-  
-  function printIntVariable
-    input Integer var[:];
-    input Integer n;
-    input String varName;
-    external "C" printIntVariables(var,n,varName)     annotation(Include="#include \"fmuWrapper.h\"",Library = "fmuWrapper.o"); 
-  end printIntVariable;
-  
-  function Bool2Int
-    input Integer dim;
-    input Boolean in_bv[dim];
-    output Integer out_iv[dim];
-  algorithm 
-    for i in 1:dim loop
-          out_iv[i]:=if in_bv[i] then 1 else 0;
-    end for;
-  end Bool2Int;
-  
-  function Int2Bool
-    input Integer dim;
-    input Integer in_iv[dim];
-    output Boolean out_bv[dim];
-  algorithm 
-    for i in 1:dim loop
-          out_bv[i]:=if in_iv[i] == 1 then true else false;
-    end for;
-  end Int2Bool;
-  
\ No newline at end of file