(* Specialized implementation of ADD for TIME *)
FUNCTION ADD__TIME__TIME: TIME
VAR_INPUT
    IN1: TIME;
    IN2: TIME;
END_VAR
    ADD__TIME__TIME := ADD_TIME(IN1, IN2);
END_FUNCTION

FUNCTION ADD__LTIME__LTIME: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LTIME;
END_VAR
    ADD__LTIME__LTIME := ADD_LTIME(IN1, IN2);
END_FUNCTION

(********************
*
* This operator returns the value of adding up two TIME operands.
*
*********************)
{external}
FUNCTION ADD_TIME: TIME
VAR_INPUT
    IN1: TIME;
    IN2: TIME;
END_VAR
END_FUNCTION

(********************
*
* This operator returns the value of adding up two LTIME operands.
*
*********************)
FUNCTION ADD_LTIME: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LTIME;
END_VAR
    ADD_LTIME := ADD_TIME(TIME#IN1, TIME#IN2);
END_FUNCTION

(* Specialized implementation of ADD for TOD *)
FUNCTION ADD__TIME_OF_DAY__TIME: TOD
VAR_INPUT
    IN1: TOD;
    IN2: TIME;
END_VAR
    ADD__TIME_OF_DAY__TIME := ADD_TOD_TIME(IN1, IN2);
END_FUNCTION

(* Specialized implementation of ADD for TOD *)
FUNCTION ADD__LTIME_OF_DAY__LTIME: LTOD
VAR_INPUT
    IN1: LTOD;
    IN2: LTIME;
END_VAR
    ADD__LTIME_OF_DAY__LTIME := ADD_LTOD_LTIME(IN1, IN2);
END_FUNCTION

(********************
*
* This operator returns the value of adding up TOD and TIME.
* Panic on overflow
*
*********************)
{external}
FUNCTION ADD_TOD_TIME: TOD
VAR_INPUT
    IN1: TOD;
    IN2: TIME;
END_VAR
END_FUNCTION

(********************
*
* This operator returns the value of adding up LTOD and LTIME.
* Panic on overflow
*
*********************)
FUNCTION ADD_LTOD_LTIME: LTOD
VAR_INPUT
    IN1: LTOD;
    IN2: LTIME;
END_VAR
    ADD_LTOD_LTIME := ADD_TOD_TIME(TOD#IN1, TIME#IN2);
END_FUNCTION

(* Specialized implementation of ADD for DT *)
FUNCTION ADD__DATE_AND_TIME__TIME: DT
VAR_INPUT
    IN1: DT;
    IN2: TIME;
END_VAR
    ADD__DATE_AND_TIME__TIME := ADD_DT_TIME(IN1, IN2);
END_FUNCTION

FUNCTION ADD__LDATE_AND_TIME__LTIME: LDT
VAR_INPUT
    IN1: LDT;
    IN2: LTIME;
END_VAR
    ADD__LDATE_AND_TIME__LTIME := ADD_LDT_LTIME(IN1, IN2);
END_FUNCTION

(********************
*
* This operator returns the value of adding up DT and TIME.
* Panic on overflow
*
*********************)
{external}
FUNCTION ADD_DT_TIME: DT
VAR_INPUT
    IN1: DT;
    IN2: TIME;
END_VAR
END_FUNCTION

(********************
*
* This operator returns the value of adding up LDT and LTIME.
* Panic on overflow
*
*********************)
FUNCTION ADD_LDT_LTIME: LDT
VAR_INPUT
    IN1: LDT;
    IN2: LTIME;
END_VAR
    ADD_LDT_LTIME := ADD_DT_TIME(DT#IN1, TIME#IN2);
END_FUNCTION

(* Specialized implementation of SUB for TIME *)
FUNCTION SUB__TIME__TIME: TIME
VAR_INPUT
    IN1: TIME;
    IN2: TIME;
END_VAR
    SUB__TIME__TIME := SUB_TIME(IN1, IN2);
END_FUNCTION

FUNCTION SUB__LTIME__LTIME: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LTIME;
END_VAR
    SUB__LTIME__LTIME := SUB_LTIME(IN1, IN2);
END_FUNCTION

(********************
*
* This operator produces the subtraction of two TIME operands
*
*********************)
{external}
FUNCTION SUB_TIME: TIME
VAR_INPUT
    IN1: TIME;
    IN2: TIME;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the subtraction of two LTIME operands
*
*********************)
FUNCTION SUB_LTIME: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LTIME;
END_VAR
    SUB_LTIME := SUB_TIME(TIME#IN1, TIME#IN2);
END_FUNCTION

(* Specialized implementation of SUB for DATE *)
FUNCTION SUB__DATE__DATE: TIME
VAR_INPUT
    IN1: DATE;
    IN2: DATE;
END_VAR
    SUB__DATE__DATE := SUB_DATE_DATE(IN1, IN2);
END_FUNCTION

FUNCTION SUB__LDATE__LDATE: LTIME
VAR_INPUT
    IN1: LDATE;
    IN2: LDATE;
END_VAR
    SUB__LDATE__LDATE := SUB_LDATE_LDATE(IN1, IN2);
END_FUNCTION

(********************
*
* This operator produces the subtraction of two DATE operands returning TIME
* Panic on overflow
*
*********************)
{external}
FUNCTION SUB_DATE_DATE: TIME
VAR_INPUT
    IN1: DATE;
    IN2: DATE;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the subtraction of two LDATE operands returning LTIME
* Panic on overflow
*
*********************)
FUNCTION SUB_LDATE_LDATE: LTIME
VAR_INPUT
    IN1: LDATE;
    IN2: LDATE;
END_VAR
    SUB_LDATE_LDATE := SUB_DATE_DATE(DATE#IN1, DATE#IN2);
END_FUNCTION

(* Specialized implementation of SUB for TOD and TIME *)
FUNCTION SUB__TIME_OF_DAY__TIME: TOD
VAR_INPUT
    IN1: TOD;
    IN2: TIME;
END_VAR
    SUB__TIME_OF_DAY__TIME := SUB_TOD_TIME(IN1, IN2);
END_FUNCTION

FUNCTION SUB__LTIME_OF_DAY__LTIME: LTOD
VAR_INPUT
    IN1: LTOD;
    IN2: LTIME;
END_VAR
    SUB__LTIME_OF_DAY__LTIME := SUB_LTOD_LTIME(IN1, IN2);
END_FUNCTION

(********************
*
* This operator produces the subtraction of TOD and TIME returning TOD
* Panic on overflow
*
*********************)
{external}
FUNCTION SUB_TOD_TIME: TOD
VAR_INPUT
    IN1: TOD;
    IN2: TIME;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the subtraction of LTOD and LTIME returning LTOD
* Panic on overflow
*
*********************)
FUNCTION SUB_LTOD_LTIME: LTOD
VAR_INPUT
    IN1: LTOD;
    IN2: LTIME;
END_VAR
    SUB_LTOD_LTIME := SUB_TOD_TIME(TOD#IN1, TIME#IN2);
END_FUNCTION

(* Specialized implementation of SUB for TOD *)
FUNCTION SUB__TIME_OF_DAY__TIME_OF_DAY: TIME
VAR_INPUT
    IN1: TOD;
    IN2: TOD;
END_VAR
    SUB__TIME_OF_DAY__TIME_OF_DAY := SUB_TOD_TOD(IN1, IN2);
END_FUNCTION

FUNCTION SUB__LTIME_OF_DAY__LTIME_OF_DAY: LTIME
VAR_INPUT
    IN1: LTOD;
    IN2: LTOD;
END_VAR
    SUB__LTIME_OF_DAY__LTIME_OF_DAY := SUB_LTOD_LTOD(IN1, IN2);
END_FUNCTION

(********************
*
* This operator produces the subtraction of two TOD operands returning TIME
* Panic on overflow
*
*********************)
{external}
FUNCTION SUB_TOD_TOD: TIME
VAR_INPUT
    IN1: TOD;
    IN2: TOD;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the subtraction of two LTOD operands returning LTIME
* Panic on overflow
*
*********************)
FUNCTION SUB_LTOD_LTOD: LTIME
VAR_INPUT
    IN1: LTOD;
    IN2: LTOD;
END_VAR
    SUB_LTOD_LTOD := SUB_TOD_TOD(TOD#IN1, TOD#IN2);
END_FUNCTION

(* Specialized implementation of SUB for DT and TIME *)
FUNCTION SUB__DATE_AND_TIME__TIME: DT
VAR_INPUT
    IN1: DT;
    IN2: TIME;
END_VAR
    SUB__DATE_AND_TIME__TIME := SUB_DT_TIME(IN1, IN2);
END_FUNCTION

(* Specialized implementation of SUB for DT and TIME *)
FUNCTION SUB__LDATE_AND_TIME__LTIME: LDT
VAR_INPUT
    IN1: LDT;
    IN2: LTIME;
END_VAR
    SUB__LDATE_AND_TIME__LTIME := SUB_LDT_LTIME(IN1, IN2);
END_FUNCTION

(********************
*
* This operator produces the subtraction of DT and TIME returning DT
* Panic on overflow
*
*********************)
{external}
FUNCTION SUB_DT_TIME: DT
VAR_INPUT
    IN1: DT;
    IN2: TIME;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the subtraction of LDT and LTIME returning LDT
* Panic on overflow
*
*********************)
FUNCTION SUB_LDT_LTIME: LDT
VAR_INPUT
    IN1: LDT;
    IN2: LTIME;
END_VAR
    SUB_LDT_LTIME := SUB_DT_TIME(DT#IN1, TIME#IN2);
END_FUNCTION

(* Specialized implementation of SUB for DT *)
FUNCTION SUB__DATE_AND_TIME__DATE_AND_TIME: TIME
VAR_INPUT
    IN1: DT;
    IN2: DT;
END_VAR
    SUB__DATE_AND_TIME__DATE_AND_TIME := SUB_DT_DT(IN1, IN2);
END_FUNCTION

FUNCTION SUB__LDATE_AND_TIME__LDATE_AND_TIME: LTIME
VAR_INPUT
    IN1: LDT;
    IN2: LDT;
END_VAR
    SUB__LDATE_AND_TIME__LDATE_AND_TIME := SUB_LDT_LDT(IN1, IN2);
END_FUNCTION

(********************
*
* This operator produces the subtraction of two DT operands returning TIME
* Panic on overflow
*
*********************)
{external}
FUNCTION SUB_DT_DT: TIME
VAR_INPUT
    IN1: DT;
    IN2: DT;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the subtraction of two LDT operands returning LTIME
* Panic on overflow
*
*********************)
FUNCTION SUB_LDT_LDT: LTIME
VAR_INPUT
    IN1: LDT;
    IN2: LDT;
END_VAR
    SUB_LDT_LDT := SUB_DT_DT(DT#IN1, DT#IN2);
END_FUNCTION

(********************
*
* This operator produces the multiplication of the operands.
* It overloads the variadic builtin implementation of MUL, which is impemented for ANY_NUM
*
*********************)
FUNCTION MUL < T1: ANY, T2: ANY >: T1
VAR_INPUT
    IN1: T1;
    IN2: T2;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the multiplication of TIME and ANY_NUM.
*
*********************)
FUNCTION MUL_TIME < T: ANY_NUM >: TIME
VAR_INPUT
    IN1: TIME;
    IN2: T;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_TIME__SINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: SINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_TIME__INT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: INT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_TIME__DINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: DINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_TIME__LINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: LINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_TIME__USINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: USINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_TIME__UINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: UINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_TIME__UDINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: UDINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_TIME__ULINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: ULINT;
END_VAR
END_FUNCTION


(********************
*
* This operator produces the multiplication of LTIME and ANY_NUM.
*
*********************)
FUNCTION MUL_LTIME < T: ANY_NUM >: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: T;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__SINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: SINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__INT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: INT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__DINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: DINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__LINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__USINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: USINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__UINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: UINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__UDINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: UDINT;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__ULINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: ULINT;
END_VAR
END_FUNCTION

(********************
*
* External declarations for TIME/LTIME multiplication with signed integers
*
*********************)

{external}
FUNCTION MUL__TIME__SINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: SINT;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__SINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: SINT;
END_VAR
    MUL__LTIME__SINT := MUL__TIME__SINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION MUL__TIME__INT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: INT;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__INT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: INT;
END_VAR
    MUL__LTIME__INT := MUL__TIME__INT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION MUL__TIME__DINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: DINT;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__DINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: DINT;
END_VAR
    MUL__LTIME__DINT := MUL__TIME__DINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION MUL__TIME__LINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: LINT;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__LINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LINT;
END_VAR
    MUL__LTIME__LINT := MUL__TIME__LINT(TIME#IN1, IN2);
END_FUNCTION

(********************
*
* External declarations for TIME/LTIME multiplication with unsigned integers
*
*********************)

{external}
FUNCTION MUL__TIME__USINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: USINT;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__USINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: USINT;
END_VAR
    MUL__LTIME__USINT := MUL__TIME__USINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION MUL__TIME__UINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: UINT;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__UINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: UINT;
END_VAR
    MUL__LTIME__UINT := MUL__TIME__UINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION MUL__TIME__UDINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: UDINT;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__UDINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: UDINT;
END_VAR
    MUL__LTIME__UDINT := MUL__TIME__UDINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION MUL__TIME__ULINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: ULINT;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__ULINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: ULINT;
END_VAR
    MUL__LTIME__ULINT := MUL__TIME__ULINT(TIME#IN1, IN2);
END_FUNCTION

(********************
*
* External declarations for TIME/LTIME multiplication with floating point
*
*********************)

{external}
FUNCTION MUL__TIME__REAL: TIME
VAR_INPUT
    IN1: TIME;
    IN2: REAL;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__REAL: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: REAL;
END_VAR
    MUL__LTIME__REAL := MUL__TIME__REAL(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION MUL_TIME__REAL: TIME
VAR_INPUT
    IN1: TIME;
    IN2: REAL;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__REAL: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: REAL;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL__TIME__LREAL: TIME
VAR_INPUT
    IN1: TIME;
    IN2: LREAL;
END_VAR
END_FUNCTION

FUNCTION MUL__LTIME__LREAL: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LREAL;
END_VAR
    MUL__LTIME__LREAL := MUL__TIME__LREAL(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION MUL_TIME__LREAL: TIME
VAR_INPUT
    IN1: TIME;
    IN2: LREAL;
END_VAR
END_FUNCTION

{external}
FUNCTION MUL_LTIME__LREAL: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LREAL;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the division of TIME and ANY_NUM.
*
*********************)
FUNCTION DIV_TIME < T: ANY_NUM >: TIME
VAR_INPUT
    IN1: TIME;
    IN2: T;
END_VAR
END_FUNCTION

(********************
*
* This operator produces the division of LTIME and ANY_NUM.
*
*********************)
FUNCTION DIV_LTIME < T: ANY_NUM >: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: T;
END_VAR
END_FUNCTION

(********************
*
* External declarations for TIME/LTIME division with signed integers
*
*********************)

{external}
FUNCTION DIV__TIME__SINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: SINT;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__SINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: SINT;
END_VAR
    DIV__LTIME__SINT := DIV__TIME__SINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV__TIME__INT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: INT;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__INT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: INT;
END_VAR
    DIV__LTIME__INT := DIV__TIME__INT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV__TIME__DINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: DINT;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__DINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: DINT;
END_VAR
    DIV__LTIME__DINT := DIV__TIME__DINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV__TIME__LINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: LINT;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__LINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LINT;
END_VAR
    DIV__LTIME__LINT := DIV__TIME__LINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV_TIME__SINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: SINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_TIME__INT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: INT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_TIME__DINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: DINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_TIME__LINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: LINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__SINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: SINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__INT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: INT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__DINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: DINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__LINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LINT;
END_VAR
END_FUNCTION

(********************
*
* External declarations for TIME/LTIME division with unsigned integers
*
*********************)

{external}
FUNCTION DIV__TIME__USINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: USINT;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__USINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: USINT;
END_VAR
    DIV__LTIME__USINT := DIV__TIME__USINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV__TIME__UINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: UINT;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__UINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: UINT;
END_VAR
    DIV__LTIME__UINT := DIV__TIME__UINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV__TIME__UDINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: UDINT;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__UDINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: UDINT;
END_VAR
    DIV__LTIME__UDINT := DIV__TIME__UDINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV__TIME__ULINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: ULINT;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__ULINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: ULINT;
END_VAR
    DIV__LTIME__ULINT := DIV__TIME__ULINT(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV_TIME__USINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: USINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_TIME__UINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: UINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_TIME__UDINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: UDINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_TIME__ULINT: TIME
VAR_INPUT
    IN1: TIME;
    IN2: ULINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__USINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: USINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__UINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: UINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__UDINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: UDINT;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__ULINT: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: ULINT;
END_VAR
END_FUNCTION

(********************
*
* External declarations for TIME/LTIME division with floating point
*
*********************)

{external}
FUNCTION DIV__TIME__REAL: TIME
VAR_INPUT
    IN1: TIME;
    IN2: REAL;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__REAL: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: REAL;
END_VAR
    DIV__LTIME__REAL := DIV__TIME__REAL(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV_TIME__REAL: TIME
VAR_INPUT
    IN1: TIME;
    IN2: REAL;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__REAL: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: REAL;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV__TIME__LREAL: TIME
VAR_INPUT
    IN1: TIME;
    IN2: LREAL;
END_VAR
END_FUNCTION

FUNCTION DIV__LTIME__LREAL: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LREAL;
END_VAR
    DIV__LTIME__LREAL := DIV__TIME__LREAL(TIME#IN1, IN2);
END_FUNCTION

{external}
FUNCTION DIV_TIME__LREAL: TIME
VAR_INPUT
    IN1: TIME;
    IN2: LREAL;
END_VAR
END_FUNCTION

{external}
FUNCTION DIV_LTIME__LREAL: LTIME
VAR_INPUT
    IN1: LTIME;
    IN2: LREAL;
END_VAR
END_FUNCTION