(********************
*
* Converts LWORD to LREAL
*
*********************)
{external}
FUNCTION LWORD_TO_LREAL : LREAL
VAR_INPUT
    in : LWORD;
END_VAR
END_FUNCTION

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

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

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

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

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

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

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

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

(********************
*
* Converts DWORD to REAL
*
*********************)
{external}
FUNCTION DWORD_TO_REAL : REAL
VAR_INPUT
    in : DWORD;
END_VAR
END_FUNCTION

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(********************
*
* Converts BOOL to LINT
*
*********************)
FUNCTION BOOL_TO_LINT : LINT
VAR_INPUT
    in : BOOL;
END_VAR
    BOOL_TO_LINT := LINT#in;
END_FUNCTION

(********************
*
* Converts BOOL to DINT
*
*********************)
FUNCTION BOOL_TO_DINT : DINT
VAR_INPUT
    in : BOOL;
END_VAR
    BOOL_TO_DINT := DINT#in;
END_FUNCTION

(********************
*
* Converts BOOL to INT
*
*********************)
FUNCTION BOOL_TO_INT : INT
VAR_INPUT
    in : BOOL;
END_VAR
    BOOL_TO_INT := INT#in;
END_FUNCTION

(********************
*
* Converts BOOL to SINT
*
*********************)
FUNCTION BOOL_TO_SINT : SINT
VAR_INPUT
    in : BOOL;
END_VAR
    BOOL_TO_SINT := SINT#in;
END_FUNCTION

(********************
*
* Converts BOOL to ULINT
*
*********************)
FUNCTION BOOL_TO_ULINT : ULINT
VAR_INPUT
    in : BOOL;
END_VAR
    BOOL_TO_ULINT := ULINT#in;
END_FUNCTION

(********************
*
* Converts BOOL to UDINT
*
*********************)
FUNCTION BOOL_TO_UDINT : UDINT
VAR_INPUT
    in : BOOL;
END_VAR
    BOOL_TO_UDINT := UDINT#in;
END_FUNCTION

(********************
*
* Converts BOOL to UINT
*
*********************)
FUNCTION BOOL_TO_UINT : UINT
VAR_INPUT
    in : BOOL;
END_VAR
    BOOL_TO_UINT := UINT#in;
END_FUNCTION

(********************
*
* Converts BOOL to USINT
*
*********************)
FUNCTION BOOL_TO_USINT : USINT
VAR_INPUT
    in : BOOL;
END_VAR
    BOOL_TO_USINT := USINT#in;
END_FUNCTION

(********************
*
* Converts LREAL to LWORD
*
*********************)
{external}
FUNCTION LREAL_TO_LWORD : LWORD
VAR_INPUT
    in : LREAL;
END_VAR
END_FUNCTION

(********************
*
* Converts REAL to DWORD
*
*********************)
{external}
FUNCTION REAL_TO_DWORD : DWORD
VAR_INPUT
    in : REAL;
END_VAR
END_FUNCTION

(********************
*
* Converts LINT to LWORD
*
*********************)
FUNCTION LINT_TO_LWORD : LWORD
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_LWORD := lword#in;
END_FUNCTION

(********************
*
* Converts LINT to DWORD
*
*********************)
FUNCTION LINT_TO_DWORD : DWORD
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_DWORD := dword#in;
END_FUNCTION

(********************
*
* Converts LINT to WORD
*
*********************)
FUNCTION LINT_TO_WORD : WORD
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_WORD := word#in;
END_FUNCTION

(********************
*
* Converts LINT to BYTE
*
*********************)
FUNCTION LINT_TO_BYTE : BYTE
VAR_INPUT
    in : LINT;
END_VAR
    LINT_TO_BYTE := byte#in;
END_FUNCTION

(********************
*
* Converts DINT to LWORD
*
*********************)
FUNCTION DINT_TO_LWORD : LWORD
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_LWORD := lword#in;
END_FUNCTION

(********************
*
* Converts DINT to DWORD
*
*********************)
FUNCTION DINT_TO_DWORD : DWORD
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_DWORD := dword#in;
END_FUNCTION

(********************
*
* Converts DINT to WORD
*
*********************)
FUNCTION DINT_TO_WORD : WORD
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_WORD := word#in;
END_FUNCTION

(********************
*
* Converts DINT to BYTE
*
*********************)
FUNCTION DINT_TO_BYTE : BYTE
VAR_INPUT
    in : DINT;
END_VAR
    DINT_TO_BYTE := byte#in;
END_FUNCTION

(********************
*
* Converts INT to LWORD
*
*********************)
FUNCTION INT_TO_LWORD : LWORD
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_LWORD := lword#in;
END_FUNCTION

(********************
*
* Converts INT to DWORD
*
*********************)
FUNCTION INT_TO_DWORD : DWORD
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_DWORD := dword#in;
END_FUNCTION

(********************
*
* Converts INT to WORD
*
*********************)
FUNCTION INT_TO_WORD : WORD
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_WORD := word#in;
END_FUNCTION

(********************
*
* Converts INT to BYTE
*
*********************)
FUNCTION INT_TO_BYTE : BYTE
VAR_INPUT
    in : INT;
END_VAR
    INT_TO_BYTE := byte#in;
END_FUNCTION

(********************
*
* Converts SINT to LWORD
*
*********************)
FUNCTION SINT_TO_LWORD : LWORD
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_LWORD := lword#in;
END_FUNCTION

(********************
*
* Converts SINT to DWORD
*
*********************)
FUNCTION SINT_TO_DWORD : DWORD
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_DWORD := dword#in;
END_FUNCTION

(********************
*
* Converts SINT to WORD
*
*********************)
FUNCTION SINT_TO_WORD : WORD
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_WORD := word#in;
END_FUNCTION

(********************
*
* Converts SINT to BYTE
*
*********************)
FUNCTION SINT_TO_BYTE : BYTE
VAR_INPUT
    in : SINT;
END_VAR
    SINT_TO_BYTE := byte#in;
END_FUNCTION

(********************
*
* Converts ULINT to LWORD
*
*********************)
FUNCTION ULINT_TO_LWORD : LWORD
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_LWORD := lword#in;
END_FUNCTION

(********************
*
* Converts ULINT to DWORD
*
*********************)
FUNCTION ULINT_TO_DWORD : DWORD
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_DWORD := dword#in;
END_FUNCTION

(********************
*
* Converts ULINT to WORD
*
*********************)
FUNCTION ULINT_TO_WORD : WORD
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_WORD := word#in;
END_FUNCTION

(********************
*
* Converts ULINT to BYTE
*
*********************)
FUNCTION ULINT_TO_BYTE : BYTE
VAR_INPUT
    in : ULINT;
END_VAR
    ULINT_TO_BYTE := byte#in;
END_FUNCTION

(********************
*
* Converts UDINT to LWORD
*
*********************)
FUNCTION UDINT_TO_LWORD : LWORD
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_LWORD := lword#in;
END_FUNCTION

(********************
*
* Converts UDINT to DWORD
*
*********************)
FUNCTION UDINT_TO_DWORD : DWORD
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_DWORD := dword#in;
END_FUNCTION

(********************
*
* Converts UDINT to WORD
*
*********************)
FUNCTION UDINT_TO_WORD : WORD
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_WORD := word#in;
END_FUNCTION

(********************
*
* Converts UDINT to BYTE
*
*********************)
FUNCTION UDINT_TO_BYTE : BYTE
VAR_INPUT
    in : UDINT;
END_VAR
    UDINT_TO_BYTE := byte#in;
END_FUNCTION

(********************
*
* Converts UINT to LWORD
*
*********************)
FUNCTION UINT_TO_LWORD : LWORD
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_LWORD := lword#in;
END_FUNCTION

(********************
*
* Converts UINT to DWORD
*
*********************)
FUNCTION UINT_TO_DWORD : DWORD
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_DWORD := dword#in;
END_FUNCTION

(********************
*
* Converts UINT to WORD
*
*********************)
FUNCTION UINT_TO_WORD : WORD
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_WORD := word#in;
END_FUNCTION

(********************
*
* Converts UINT to BYTE
*
*********************)
FUNCTION UINT_TO_BYTE : BYTE
VAR_INPUT
    in : UINT;
END_VAR
    UINT_TO_BYTE := byte#in;
END_FUNCTION

(********************
*
* Converts USINT to LWORD
*
*********************)
FUNCTION USINT_TO_LWORD : LWORD
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_LWORD := lword#in;
END_FUNCTION

(********************
*
* Converts USINT to DWORD
*
*********************)
FUNCTION USINT_TO_DWORD : DWORD
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_DWORD := dword#in;
END_FUNCTION

(********************
*
* Converts USINT to WORD
*
*********************)
FUNCTION USINT_TO_WORD : WORD
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_WORD := word#in;
END_FUNCTION

(********************
*
* Converts USINT to BYTE
*
*********************)
FUNCTION USINT_TO_BYTE : BYTE
VAR_INPUT
    in : USINT;
END_VAR
    USINT_TO_BYTE := byte#in;
END_FUNCTION