(********************
*
* Converts LREAL to REAL
*
*********************)
FUNCTION LREAL_TO_REAL : REAL
VAR_INPUT
    in : LREAL;
END_VAR
    LREAL_TO_REAL := REAL#in;
END_FUNCTION

(********************
*
* Converts LREAL to LINT
*
*********************)
FUNCTION LREAL_TO_LINT : LINT
VAR_INPUT
    in : LREAL;
END_VAR
VAR
    tmp : LREAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    LREAL_TO_LINT := lint#tmp;
END_FUNCTION

(********************
*
* Converts LREAL to DINT
*
*********************)
FUNCTION LREAL_TO_DINT : DINT
VAR_INPUT
    in : LREAL;
END_VAR
VAR
    tmp : LREAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    LREAL_TO_DINT := dint#tmp;
END_FUNCTION

(********************
*
* Converts LREAL to INT
*
*********************)
FUNCTION LREAL_TO_INT : INT
VAR_INPUT
    in : LREAL;
END_VAR
VAR
    tmp : LREAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    LREAL_TO_INT := int#tmp;
END_FUNCTION

(********************
*
* Converts LREAL to SINT
*
*********************)
FUNCTION LREAL_TO_SINT : SINT
VAR_INPUT
    in : LREAL;
END_VAR
VAR
    tmp : LREAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    LREAL_TO_SINT := sint#tmp;
END_FUNCTION

(********************
*
* Converts LREAL to ULINT
*
*********************)
FUNCTION LREAL_TO_ULINT : ULINT
VAR_INPUT
    in : LREAL;
END_VAR
VAR
    tmp : LREAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    LREAL_TO_ULINT := ulint#tmp;
END_FUNCTION

(********************
*
* Converts LREAL to UDINT
*
*********************)
FUNCTION LREAL_TO_UDINT : UDINT
VAR_INPUT
    in : LREAL;
END_VAR
VAR
    tmp : LREAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    LREAL_TO_UDINT := udint#tmp;
END_FUNCTION

(********************
*
* Converts LREAL to UINT
*
*********************)
FUNCTION LREAL_TO_UINT : UINT
VAR_INPUT
    in : LREAL;
END_VAR
VAR
    tmp : LREAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    LREAL_TO_UINT := uint#tmp;
END_FUNCTION

(********************
*
* Converts LREAL to USINT
*
*********************)
FUNCTION LREAL_TO_USINT : USINT
VAR_INPUT
    in : LREAL;
END_VAR
VAR
    tmp : LREAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    LREAL_TO_USINT := usint#tmp;
END_FUNCTION

(********************
*
* Converts REAL to LREAL
*
*********************)
FUNCTION REAL_TO_LREAL : LREAL
VAR_INPUT
    in : REAL;
END_VAR
    REAL_TO_LREAL := in;
END_FUNCTION

(********************
*
* Converts REAL to LINT
*
*********************)
FUNCTION REAL_TO_LINT : LINT
VAR_INPUT
    in : REAL;
END_VAR
VAR
    tmp : REAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    REAL_TO_LINT := lint#tmp;
END_FUNCTION

(********************
*
* Converts REAL to DINT
*
*********************)
FUNCTION REAL_TO_DINT : DINT
VAR_INPUT
    in : REAL;
END_VAR
VAR
    tmp : REAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    REAL_TO_DINT := dint#tmp;
END_FUNCTION

(********************
*
* Converts REAL to INT
*
*********************)
FUNCTION REAL_TO_INT : INT
VAR_INPUT
    in : REAL;
END_VAR
VAR
    tmp : REAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    REAL_TO_INT := int#tmp;
END_FUNCTION

(********************
*
* Converts REAL to SINT
*
*********************)
FUNCTION REAL_TO_SINT : SINT
VAR_INPUT
    in : REAL;
END_VAR
VAR
    tmp : REAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    REAL_TO_SINT := sint#tmp;
END_FUNCTION

(********************
*
* Converts REAL to ULINT
*
*********************)
FUNCTION REAL_TO_ULINT : ULINT
VAR_INPUT
    in : REAL;
END_VAR
VAR
    tmp : REAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    REAL_TO_ULINT := ulint#tmp;
END_FUNCTION

(********************
*
* Converts REAL to UDINT
*
*********************)
FUNCTION REAL_TO_UDINT : UDINT
VAR_INPUT
    in : REAL;
END_VAR
VAR
    tmp : REAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    REAL_TO_UDINT := udint#tmp;
END_FUNCTION

(********************
*
* Converts REAL to UINT
*
*********************)
FUNCTION REAL_TO_UINT : UINT
VAR_INPUT
    in : REAL;
END_VAR
VAR
    tmp: REAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    REAL_TO_UINT := uint#tmp;
END_FUNCTION

(********************
*
* Converts REAL to USINT
*
*********************)
FUNCTION REAL_TO_USINT : USINT
VAR_INPUT
    in : REAL;
END_VAR
VAR
    tmp: REAL;
END_VAR
    // HACK: old codegen does not support cast on call expr
    //       so we store the result in a temp variable
    //       remove this, once we drop support of old codegen
    tmp := ROUND(in);
    REAL_TO_USINT := usint#tmp;
END_FUNCTION

(********************
*
* Converts LINT to LREAL
*
*********************)
FUNCTION LINT_TO_LREAL : LREAL
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_LREAL := lreal#in;
END_FUNCTION

(********************
*
* Converts LINT to REAL
*
*********************)
FUNCTION LINT_TO_REAL : REAL
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_REAL := real#in;
END_FUNCTION

(********************
*
* Converts LINT to DINT
*
*********************)
FUNCTION LINT_TO_DINT : DINT
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_DINT := dint#in;
END_FUNCTION

(********************
*
* Converts LINT to INT
*
*********************)
FUNCTION LINT_TO_INT : INT
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_INT := int#in;
END_FUNCTION

(********************
*
* Converts LINT to SINT
*
*********************)
FUNCTION LINT_TO_SINT : SINT
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_SINT := sint#in;
END_FUNCTION

(********************
*
* Converts LINT to ULINT
*
*********************)
FUNCTION LINT_TO_ULINT : ULINT
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_ULINT := ulint#in;
END_FUNCTION

(********************
*
* Converts LINT to UDINT
*
*********************)
FUNCTION LINT_TO_UDINT : UDINT
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_UDINT := udint#in;
END_FUNCTION

(********************
*
* Converts LINT to UINT
*
*********************)
FUNCTION LINT_TO_UINT : UINT
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_UINT := uint#in;
END_FUNCTION

(********************
*
* Converts LINT to USINT
*
*********************)
FUNCTION LINT_TO_USINT : USINT
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_USINT := usint#in;
END_FUNCTION

(********************
*
* Converts DINT to LREAL
*
*********************)
FUNCTION DINT_TO_LREAL : LREAL
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_LREAL := in;
END_FUNCTION

(********************
*
* Converts DINT to REAL
*
*********************)
FUNCTION DINT_TO_REAL : REAL
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_REAL := real#in;
END_FUNCTION

(********************
*
* Converts DINT to LINT
*
*********************)
FUNCTION DINT_TO_LINT : LINT
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_LINT := lint#in;
END_FUNCTION

(********************
*
* Converts DINT to INT
*
*********************)
FUNCTION DINT_TO_INT : INT
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_INT := int#in;
END_FUNCTION

(********************
*
* Converts DINT to SINT
*
*********************)
FUNCTION DINT_TO_SINT : SINT
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_SINT := sint#in;
END_FUNCTION

(********************
*
* Converts DINT to ULINT
*
*********************)
FUNCTION DINT_TO_ULINT : ULINT
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_ULINT := ulint#in;
END_FUNCTION

(********************
*
* Converts DINT to UDINT
*
*********************)
FUNCTION DINT_TO_UDINT : UDINT
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_UDINT := udint#in;
END_FUNCTION

(********************
*
* Converts DINT to UINT
*
*********************)
FUNCTION DINT_TO_UINT : UINT
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_UINT := uint#in;
END_FUNCTION

(********************
*
* Converts DINT to USINT
*
*********************)
FUNCTION DINT_TO_USINT : USINT
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_USINT := usint#in;
END_FUNCTION

(********************
*
* Converts INT to LREAL
*
*********************)
FUNCTION INT_TO_LREAL : LREAL
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_LREAL := in;
END_FUNCTION

(********************
*
* Converts INT to REAL
*
*********************)
FUNCTION INT_TO_REAL : REAL
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_REAL := real#in;
END_FUNCTION

(********************
*
* Converts INT to LINT
*
*********************)
FUNCTION INT_TO_LINT : LINT
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_LINT := lint#in;
END_FUNCTION

(********************
*
* Converts INT to DINT
*
*********************)
FUNCTION INT_TO_DINT : DINT
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_DINT := dint#in;
END_FUNCTION

(********************
*
* Converts INT to SINT
*
*********************)
FUNCTION INT_TO_SINT : SINT
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_SINT := sint#in;
END_FUNCTION

(********************
*
* Converts INT to ULINT
*
*********************)
FUNCTION INT_TO_ULINT : ULINT
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_ULINT := ulint#in;
END_FUNCTION

(********************
*
* Converts INT to UDINT
*
*********************)
FUNCTION INT_TO_UDINT : UDINT
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_UDINT := udint#in;
END_FUNCTION

(********************
*
* Converts INT to UINT
*
*********************)
FUNCTION INT_TO_UINT : UINT
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_UINT := uint#in;
END_FUNCTION

(********************
*
* Converts INT to USINT
*
*********************)
FUNCTION INT_TO_USINT : USINT
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_USINT := usint#in;
END_FUNCTION

(********************
*
* Converts SINT to LREAL
*
*********************)
FUNCTION SINT_TO_LREAL : LREAL
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_LREAL := in;
END_FUNCTION

(********************
*
* Converts SINT to REAL
*
*********************)
FUNCTION SINT_TO_REAL : REAL
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_REAL := real#in;
END_FUNCTION

(********************
*
* Converts SINT to LINT
*
*********************)
FUNCTION SINT_TO_LINT : LINT
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_LINT := lint#in;
END_FUNCTION

(********************
*
* Converts SINT to DINT
*
*********************)
FUNCTION SINT_TO_DINT : DINT
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_DINT := dint#in;
END_FUNCTION

(********************
*
* Converts SINT to INT
*
*********************)
FUNCTION SINT_TO_INT : INT
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_INT := int#in;
END_FUNCTION

(********************
*
* Converts SINT to ULINT
*
*********************)
FUNCTION SINT_TO_ULINT : ULINT
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_ULINT := ulint#in;
END_FUNCTION

(********************
*
* Converts SINT to UDINT
*
*********************)
FUNCTION SINT_TO_UDINT : UDINT
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_UDINT := udint#in;
END_FUNCTION

(********************
*
* Converts SINT to UINT
*
*********************)
FUNCTION SINT_TO_UINT : UINT
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_UINT := uint#in;
END_FUNCTION

(********************
*
* Converts SINT to USINT
*
*********************)
FUNCTION SINT_TO_USINT : USINT
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_USINT := usint#in;
END_FUNCTION

(********************
*
* Converts ULINT to LREAL
*
*********************)
FUNCTION ULINT_TO_LREAL : LREAL
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_LREAL := lreal#in;
END_FUNCTION

(********************
*
* Converts ULINT to REAL
*
*********************)
FUNCTION ULINT_TO_REAL : REAL
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_REAL := real#in;
END_FUNCTION

(********************
*
* Converts ULINT to LINT
*
*********************)
FUNCTION ULINT_TO_LINT : LINT
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_LINT := lint#in;
END_FUNCTION

(********************
*
* Converts ULINT to DINT
*
*********************)
FUNCTION ULINT_TO_DINT : DINT
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_DINT := dint#in;
END_FUNCTION

(********************
*
* Converts ULINT to INT
*
*********************)
FUNCTION ULINT_TO_INT : INT
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_INT := int#in;
END_FUNCTION

(********************
*
* Converts ULINT to SINT
*
*********************)
FUNCTION ULINT_TO_SINT : SINT
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_SINT := sint#in;
END_FUNCTION

(********************
*
* Converts ULINT to UDINT
*
*********************)
FUNCTION ULINT_TO_UDINT : UDINT
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_UDINT := udint#in;
END_FUNCTION

(********************
*
* Converts ULINT to UINT
*
*********************)
FUNCTION ULINT_TO_UINT : UINT
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_UINT := uint#in;
END_FUNCTION

(********************
*
* Converts ULINT to USINT
*
*********************)
FUNCTION ULINT_TO_USINT : USINT
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_USINT := usint#in;
END_FUNCTION

(********************
*
* Converts UDINT to LREAL
*
*********************)
FUNCTION UDINT_TO_LREAL : LREAL
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_LREAL := in;
END_FUNCTION

(********************
*
* Converts UDINT to REAL
*
*********************)
FUNCTION UDINT_TO_REAL : REAL
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_REAL := real#in;
END_FUNCTION

(********************
*
* Converts UDINT to LINT
*
*********************)
FUNCTION UDINT_TO_LINT : LINT
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_LINT := lint#in;
END_FUNCTION

(********************
*
* Converts UDINT to DINT
*
*********************)
FUNCTION UDINT_TO_DINT : DINT
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_DINT := dint#in;
END_FUNCTION

(********************
*
* Converts UDINT to INT
*
*********************)
FUNCTION UDINT_TO_INT : INT
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_INT := int#in;
END_FUNCTION

(********************
*
* Converts UDINT to SINT
*
*********************)
FUNCTION UDINT_TO_SINT : SINT
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_SINT := sint#in;
END_FUNCTION

(********************
*
* Converts UDINT to ULINT
*
*********************)
FUNCTION UDINT_TO_ULINT : ULINT
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_ULINT := ulint#in;
END_FUNCTION

(********************
*
* Converts UDINT to UINT
*
*********************)
FUNCTION UDINT_TO_UINT : UINT
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_UINT := uint#in;
END_FUNCTION

(********************
*
* Converts UDINT to USINT
*
*********************)
FUNCTION UDINT_TO_USINT : USINT
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_USINT := usint#in;
END_FUNCTION

(********************
*
* Converts UINT to LREAL
*
*********************)
FUNCTION UINT_TO_LREAL : LREAL
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_LREAL := in;
END_FUNCTION

(********************
*
* Converts UINT to REAL
*
*********************)
FUNCTION UINT_TO_REAL : REAL
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_REAL := real#in;
END_FUNCTION

(********************
*
* Converts UINT to LINT
*
*********************)
FUNCTION UINT_TO_LINT : LINT
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_LINT := lint#in;
END_FUNCTION

(********************
*
* Converts UINT to DINT
*
*********************)
FUNCTION UINT_TO_DINT : DINT
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_DINT := dint#in;
END_FUNCTION

(********************
*
* Converts UINT to INT
*
*********************)
FUNCTION UINT_TO_INT : INT
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_INT := int#in;
END_FUNCTION

(********************
*
* Converts UINT to SINT
*
*********************)
FUNCTION UINT_TO_SINT : SINT
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_SINT := sint#in;
END_FUNCTION

(********************
*
* Converts UINT to ULINT
*
*********************)
FUNCTION UINT_TO_ULINT : ULINT
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_ULINT := ulint#in;
END_FUNCTION

(********************
*
* Converts UINT to UDINT
*
*********************)
FUNCTION UINT_TO_UDINT : UDINT
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_UDINT := udint#in;
END_FUNCTION

(********************
*
* Converts UINT to USINT
*
*********************)
FUNCTION UINT_TO_USINT : USINT
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_USINT := usint#in;
END_FUNCTION

(********************
*
* Converts USINT to LREAL
*
*********************)
FUNCTION USINT_TO_LREAL : LREAL
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_LREAL := in;
END_FUNCTION

(********************
*
* Converts USINT to REAL
*
*********************)
FUNCTION USINT_TO_REAL : REAL
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_REAL := real#in;
END_FUNCTION

(********************
*
* Converts USINT to LINT
*
*********************)
FUNCTION USINT_TO_LINT : LINT
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_LINT := lint#in;
END_FUNCTION

(********************
*
* Converts USINT to DINT
*
*********************)
FUNCTION USINT_TO_DINT : DINT
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_DINT := dint#in;
END_FUNCTION

(********************
*
* Converts USINT to INT
*
*********************)
FUNCTION USINT_TO_INT : INT
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_INT := int#in;
END_FUNCTION

(********************
*
* Converts USINT to SINT
*
*********************)
FUNCTION USINT_TO_SINT : SINT
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_SINT := sint#in;
END_FUNCTION

(********************
*
* Converts USINT to ULINT
*
*********************)
FUNCTION USINT_TO_ULINT : ULINT
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_ULINT := ulint#in;
END_FUNCTION

(********************
*
* Converts USINT to UDINT
*
*********************)
FUNCTION USINT_TO_UDINT : UDINT
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_UDINT := udint#in;
END_FUNCTION

(********************
*
* Converts USINT to UINT
*
*********************)
FUNCTION USINT_TO_UINT : UINT
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_UINT := uint#in;
END_FUNCTION