From faabeadf9f3a72f159177108d73ec3418b9cd28a Mon Sep 17 00:00:00 2001
From: Merlijn Wajer <merlijn@wizzup.org>
Date: Sun, 13 May 2012 00:02:33 +0200
Subject: [PATCH] Change most methods to cdecl.

---
 lape.inc                     |    3 +
 lpeval.pas                   |  206 +-
 lpeval_functions.inc         | 5659 +++++++++++++++++++++---------------------
 lpeval_headers_datetime.inc  |   38 +-
 lpeval_headers_math.inc      |   40 +-
 lpeval_headers_string.inc    |  100 +-
 lpeval_headers_variant.inc   |  104 +-
 lpeval_wrappers_datetime.inc |   38 +-
 lpeval_wrappers_math.inc     |   40 +-
 lpeval_wrappers_string.inc   |  100 +-
 lpeval_wrappers_variant.inc  |   82 +-
 lptypes.pas                  |    6 +-
 12 files changed, 3229 insertions(+), 3187 deletions(-)

diff --git a/lape.inc b/lape.inc
index 3eb4461..36729fb 100644
--- a/lape.inc
+++ b/lape.inc
@@ -21,3 +21,6 @@
   {$DEFINE Delphi}
   {$POINTERMATH ON}
 {$ENDIF}
+
+{$MACRO ON}
+{$define lape_extdecl:=cdecl;}
\ No newline at end of file
diff --git a/lpeval.pas b/lpeval.pas
index 7805174..a53346a 100644
--- a/lpeval.pas
+++ b/lpeval.pas
@@ -22,57 +22,57 @@ type
   TGetEvalRes = function(Op: EOperator; Left, Right: ELapeBaseType): ELapeBaseType;
   TGetEvalProc = function(Op: EOperator; Left, Right: ELapeBaseType): TLapeEvalProc;
 
-procedure _LapeWrite(const Params: PParamArray);
-procedure _LapeWriteLn(const Params: PParamArray);
-
-procedure _LapeAssigned(const Params: PParamArray; const Result: Pointer);
-procedure _LapeRaise(const Params: PParamArray);
-procedure _LapeRaiseString(const Params: PParamArray);
-procedure _LapeAssert(const Params: PParamArray);
-procedure _LapeAssertMsg(const Params: PParamArray);
-
-procedure _LapeGetMem(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAllocMem(const Params: PParamArray; const Result: Pointer);
-procedure _LapeFreeMem(const Params: PParamArray);
-procedure _LapeFreeMemSize(const Params: PParamArray);
-procedure _LapeReallocMem(const Params: PParamArray);
-procedure _LapeFillMem(const Params: PParamArray);
-procedure _LapeMove(const Params: PParamArray);
-
-procedure _LapeHigh(const Params: PParamArray; const Result: Pointer);
-procedure _LapeLength(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAStr_GetLen(const Params: PParamArray; const Result: Pointer);
-procedure _LapeWStr_GetLen(const Params: PParamArray; const Result: Pointer);
-procedure _LapeUStr_GetLen(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAStr_SetLen(const Params: PParamArray);
-procedure _LapeWStr_SetLen(const Params: PParamArray);
-procedure _LapeUStr_SetLen(const Params: PParamArray);
-
-procedure _LapeToString_Unknown(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_UInt8(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Int8(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_UInt16(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Int16(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_UInt32(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Int32(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_UInt64(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Int64(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Single(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Double(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Currency(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Extended(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Boolean(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_ByteBool(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_WordBool(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_LongBool(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_AnsiChar(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_WideChar(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_ShortString(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_AnsiString(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_WideString(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_UnicodeString(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Variant(const Params: PParamArray; const Result: Pointer);
-procedure _LapeToString_Pointer(const Params: PParamArray; const Result: Pointer);
+procedure _LapeWrite(const Params: PParamArray); lape_extdecl
+procedure _LapeWriteLn(const Params: PParamArray); lape_extdecl
+
+procedure _LapeAssigned(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeRaise(const Params: PParamArray); lape_extdecl
+procedure _LapeRaiseString(const Params: PParamArray); lape_extdecl
+procedure _LapeAssert(const Params: PParamArray); lape_extdecl
+procedure _LapeAssertMsg(const Params: PParamArray); lape_extdecl
+
+procedure _LapeGetMem(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAllocMem(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeFreeMem(const Params: PParamArray); lape_extdecl
+procedure _LapeFreeMemSize(const Params: PParamArray); lape_extdecl
+procedure _LapeReallocMem(const Params: PParamArray); lape_extdecl
+procedure _LapeFillMem(const Params: PParamArray); lape_extdecl
+procedure _LapeMove(const Params: PParamArray); lape_extdecl
+
+procedure _LapeHigh(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeLength(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAStr_GetLen(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeWStr_GetLen(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeUStr_GetLen(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAStr_SetLen(const Params: PParamArray); lape_extdecl
+procedure _LapeWStr_SetLen(const Params: PParamArray); lape_extdecl
+procedure _LapeUStr_SetLen(const Params: PParamArray); lape_extdecl
+
+procedure _LapeToString_Unknown(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_UInt8(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Int8(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_UInt16(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Int16(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_UInt32(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Int32(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_UInt64(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Int64(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Single(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Double(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Currency(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Extended(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Boolean(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_ByteBool(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_WordBool(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_LongBool(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_AnsiChar(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_WideChar(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_ShortString(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_AnsiString(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_WideString(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_UnicodeString(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Variant(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeToString_Pointer(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
 {$I lpeval_headers_math.inc}
 {$I lpeval_headers_string.inc}
@@ -85,7 +85,7 @@ procedure LoadToStrArr(var Arr: TLapeToStrArr);
 function ValidEvalFunction(p: Pointer): Boolean; overload; {$IFDEF Lape_Inline}inline;{$ENDIF}
 function ValidEvalFunction(p: TLapeEvalProc): Boolean; overload; {$IFDEF Lape_Inline}inline;{$ENDIF}
 
-procedure LapeEval_Error(const Dest, Left, Right: Pointer);
+procedure LapeEval_Error(const Dest, Left, Right: Pointer); lape_extdecl
 procedure ClearEvalRes(var Arr: TLapeEvalRes);
 procedure ClearEvalArr(var Arr: TLapeEvalArr);
 procedure LoadEvalRes(var Arr: TLapeEvalRes);
@@ -268,234 +268,234 @@ uses
 type
   PBoolean = ^Boolean; //Make sure it's not ^Byte
 
-procedure _LapeWrite(const Params: PParamArray);
+procedure _LapeWrite(const Params: PParamArray); lape_extdecl
 begin
   Write(PlpString(Params^[0])^);
 end;
 
-procedure _LapeWriteLn(const Params: PParamArray);
+procedure _LapeWriteLn(const Params: PParamArray); lape_extdecl
 begin
   WriteLn('');
 end;
 
-procedure _LapeAssigned(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAssigned(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := Assigned(PPointer(Params^[0])^);
 end;
 
-procedure _LapeRaise(const Params: PParamArray);
+procedure _LapeRaise(const Params: PParamArray); lape_extdecl
 begin
   raise Exception(Params^[0]^);
 end;
 
-procedure _LapeRaiseString(const Params: PParamArray);
+procedure _LapeRaiseString(const Params: PParamArray); lape_extdecl
 begin
   LapeException(PlpString(Params^[0])^);
 end;
 
-procedure _LapeAssert(const Params: PParamArray);
+procedure _LapeAssert(const Params: PParamArray); lape_extdecl
 begin
   if (not PEvalBool(Params^[0])^) then
     LapeException(lpeAssertionFailure);
 end;
 
-procedure _LapeAssertMsg(const Params: PParamArray);
+procedure _LapeAssertMsg(const Params: PParamArray); lape_extdecl
 begin
   if (not PEvalBool(Params^[0])^) then
     LapeExceptionFmt(lpeAssertionFailureMsg, [PlpString(Params^[1])^]);
 end;
 
-procedure _LapeGetMem(const Params: PParamArray; const Result: Pointer);
+procedure _LapeGetMem(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   GetMem(PPointer(Result)^, PInt32(Params^[0])^);
 end;
 
-procedure _LapeAllocMem(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAllocMem(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PPointer(Result)^ := AllocMem(PInt32(Params^[0])^);
 end;
 
-procedure _LapeFreeMem(const Params: PParamArray);
+procedure _LapeFreeMem(const Params: PParamArray); lape_extdecl
 begin
   FreeMem(PPointer(Params^[0])^);
 end;
 
-procedure _LapeFreeMemSize(const Params: PParamArray);
+procedure _LapeFreeMemSize(const Params: PParamArray); lape_extdecl
 begin
   FreeMem(PPointer(Params^[0])^, PInt32(Params^[1])^);
 end;
 
-procedure _LapeReallocMem(const Params: PParamArray);
+procedure _LapeReallocMem(const Params: PParamArray); lape_extdecl
 begin
   ReallocMem(PPointer(Params^[0])^, PInt32(Params^[1])^);
 end;
 
-procedure _LapeFillMem(const Params: PParamArray);
+procedure _LapeFillMem(const Params: PParamArray); lape_extdecl
 begin
   FillChar(Params^[0]^, PInt32(Params^[1])^, PUInt8(Params^[2])^);
 end;
 
-procedure _LapeMove(const Params: PParamArray);
+procedure _LapeMove(const Params: PParamArray); lape_extdecl
 begin
   Move(Params^[0]^, Params^[1]^, PInt32(Params^[2])^);
 end;
 
-procedure _LapeHigh(const Params: PParamArray; const Result: Pointer);
+procedure _LapeHigh(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := High(PCodeArray(Params^[0])^);
 end;
 
-procedure _LapeLength(const Params: PParamArray; const Result: Pointer);
+procedure _LapeLength(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := Length(PCodeArray(Params^[0])^);
 end;
 
-procedure _LapeAStr_GetLen(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAStr_GetLen(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := Length(PAnsiString(Params^[0])^);
 end;
 
-procedure _LapeWStr_GetLen(const Params: PParamArray; const Result: Pointer);
+procedure _LapeWStr_GetLen(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := Length(PWideString(Params^[0])^);
 end;
 
-procedure _LapeUStr_GetLen(const Params: PParamArray; const Result: Pointer);
+procedure _LapeUStr_GetLen(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := Length(PUnicodeString(Params^[0])^);
 end;
 
-procedure _LapeAStr_SetLen(const Params: PParamArray);
+procedure _LapeAStr_SetLen(const Params: PParamArray); lape_extdecl
 begin
   SetLength(PAnsiString(Params^[0])^, PInt32(Params^[1])^);
 end;
 
-procedure _LapeWStr_SetLen(const Params: PParamArray);
+procedure _LapeWStr_SetLen(const Params: PParamArray); lape_extdecl
 begin
   SetLength(PWideString(Params^[0])^, PInt32(Params^[1])^);
 end;
 
-procedure _LapeUStr_SetLen(const Params: PParamArray);
+procedure _LapeUStr_SetLen(const Params: PParamArray); lape_extdecl
 begin
   SetLength(PUnicodeString(Params^[0])^, PInt32(Params^[1])^);
 end;
 
-procedure _LapeToString_Unknown(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Unknown(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := '*UNKNOWN*';
 end;
 
-procedure _LapeToString_UInt8(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_UInt8(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToStr(PUInt8(Params^[0])^);
 end;
 
-procedure _LapeToString_Int8(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Int8(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToStr(PInt8(Params^[0])^);
 end;
 
-procedure _LapeToString_UInt16(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_UInt16(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToStr(PUInt16(Params^[0])^);
 end;
 
-procedure _LapeToString_Int16(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Int16(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToStr(PInt16(Params^[0])^);
 end;
 
-procedure _LapeToString_UInt32(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_UInt32(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToStr(PUInt32(Params^[0])^);
 end;
 
-procedure _LapeToString_Int32(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Int32(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToStr(PInt32(Params^[0])^);
 end;
 
-procedure _LapeToString_UInt64(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_UInt64(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToStr(PUInt64(Params^[0])^);
 end;
 
-procedure _LapeToString_Int64(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Int64(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToStr(PInt64(Params^[0])^);
 end;
 
-procedure _LapeToString_Single(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Single(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := FloatToStr(PSingle(Params^[0])^);
 end;
 
-procedure _LapeToString_Double(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Double(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := FloatToStr(PDouble(Params^[0])^);
 end;
 
-procedure _LapeToString_Currency(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Currency(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := FloatToStr(PCurrency(Params^[0])^);
 end;
 
-procedure _LapeToString_Extended(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Extended(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := FloatToStr(PExtended(Params^[0])^);
 end;
 
-procedure _LapeToString_Boolean(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Boolean(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := BoolToStr(PBoolean(Params^[0])^, True);
 end;
 
-procedure _LapeToString_ByteBool(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_ByteBool(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := BoolToStr(PBoolean(Params^[0])^, True);
 end;
 
-procedure _LapeToString_WordBool(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_WordBool(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := BoolToStr(PWordBool(Params^[0])^, True);
 end;
 
-procedure _LapeToString_LongBool(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_LongBool(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := BoolToStr(PLongBool(Params^[0])^, True);
 end;
 
-procedure _LapeToString_AnsiChar(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_AnsiChar(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := PAnsiChar(Params^[0])^;
 end;
 
-procedure _LapeToString_WideChar(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_WideChar(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := PWideChar(Params^[0])^;
 end;
 
-procedure _LapeToString_ShortString(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_ShortString(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := PShortString(Params^[0])^;
 end;
 
-procedure _LapeToString_AnsiString(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_AnsiString(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := PAnsiString(Params^[0])^;
 end;
 
-procedure _LapeToString_WideString(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_WideString(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := PWideString(Params^[0])^;
 end;
 
-procedure _LapeToString_UnicodeString(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_UnicodeString(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := PUnicodeString(Params^[0])^;
 end;
 
-procedure _LapeToString_Variant(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Variant(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   try
     PlpString(Result)^ := VarToStr(PVariant(Params^[0])^);
@@ -504,7 +504,7 @@ begin
   end;
 end;
 
-procedure _LapeToString_Pointer(const Params: PParamArray; const Result: Pointer);
+procedure _LapeToString_Pointer(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   if (PPointer(Params^[0])^ = nil) then
     PlpString(Result)^ := 'nil'
@@ -567,7 +567,7 @@ begin
    Result := ValidEvalFunction(Pointer({$IFNDEF FPC}@{$ENDIF}p));
 end;
 
-procedure LapeEval_Error(const Dest, Left, Right: Pointer);
+procedure LapeEval_Error(const Dest, Left, Right: Pointer); lape_extdecl
 begin
   LapeException(lpeInvalidEvaluation);
 end;
@@ -606,12 +606,12 @@ begin
   {$I lpeval_arr.inc}
 end;
 
-procedure lpeAddr(const Dest, Left, Right: Pointer);
+procedure lpeAddr(const Dest, Left, Right: Pointer); lape_extdecl
 begin
   PPointer(Dest)^ := Left;
 end;
 
-procedure lpeDeref(const Dest, Left, Right: Pointer);
+procedure lpeDeref(const Dest, Left, Right: Pointer); lape_extdecl
 begin
   PPointer(Dest)^ := PPointer(Left)^;
 end;
@@ -644,4 +644,6 @@ initialization
   LoadEvalArr(LapeEvalArr);
 
 end.
+
+
 
\ No newline at end of file
diff --git a/lpeval_functions.inc b/lpeval_functions.inc
index a013e3e..85bfee6 100644
--- a/lpeval_functions.inc
+++ b/lpeval_functions.inc
@@ -7,2859 +7,2896 @@
 }
 {%MainUnit lpeval.pas}
 
-procedure lpeUInt8_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PUInt8(Right)^; end;
-procedure lpeUInt8_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PInt8(Right)^; end;
-procedure lpeUInt8_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PUInt16(Right)^; end;
-procedure lpeUInt8_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PInt16(Right)^; end;
-procedure lpeUInt8_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PUInt32(Right)^; end;
-procedure lpeUInt8_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PInt32(Right)^; end;
-procedure lpeUInt8_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PUInt64(Right)^; end;
-procedure lpeUInt8_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PInt64(Right)^; end;
-procedure lpeUInt8_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PSingle(Right)^; end;
-procedure lpeUInt8_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PDouble(Right)^; end;
-procedure lpeUInt8_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PCurrency(Right)^; end;
-procedure lpeUInt8_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PExtended(Right)^; end;
-procedure lpeUInt8_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ = PVariant(Right)^; end;
-procedure lpeInt8_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PUInt8(Right)^; end;
-procedure lpeInt8_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PInt8(Right)^; end;
-procedure lpeInt8_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PUInt16(Right)^; end;
-procedure lpeInt8_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PInt16(Right)^; end;
-procedure lpeInt8_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PUInt32(Right)^; end;
-procedure lpeInt8_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PInt32(Right)^; end;
-procedure lpeInt8_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PUInt64(Right)^; end;
-procedure lpeInt8_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PInt64(Right)^; end;
-procedure lpeInt8_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PSingle(Right)^; end;
-procedure lpeInt8_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PDouble(Right)^; end;
-procedure lpeInt8_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PCurrency(Right)^; end;
-procedure lpeInt8_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PExtended(Right)^; end;
-procedure lpeInt8_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ = PVariant(Right)^; end;
-procedure lpeUInt16_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PUInt8(Right)^; end;
-procedure lpeUInt16_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PInt8(Right)^; end;
-procedure lpeUInt16_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PUInt16(Right)^; end;
-procedure lpeUInt16_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PInt16(Right)^; end;
-procedure lpeUInt16_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PUInt32(Right)^; end;
-procedure lpeUInt16_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PInt32(Right)^; end;
-procedure lpeUInt16_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PUInt64(Right)^; end;
-procedure lpeUInt16_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PInt64(Right)^; end;
-procedure lpeUInt16_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PSingle(Right)^; end;
-procedure lpeUInt16_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PDouble(Right)^; end;
-procedure lpeUInt16_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PCurrency(Right)^; end;
-procedure lpeUInt16_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PExtended(Right)^; end;
-procedure lpeUInt16_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ = PVariant(Right)^; end;
-procedure lpeInt16_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PUInt8(Right)^; end;
-procedure lpeInt16_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PInt8(Right)^; end;
-procedure lpeInt16_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PUInt16(Right)^; end;
-procedure lpeInt16_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PInt16(Right)^; end;
-procedure lpeInt16_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PUInt32(Right)^; end;
-procedure lpeInt16_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PInt32(Right)^; end;
-procedure lpeInt16_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PUInt64(Right)^; end;
-procedure lpeInt16_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PInt64(Right)^; end;
-procedure lpeInt16_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PSingle(Right)^; end;
-procedure lpeInt16_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PDouble(Right)^; end;
-procedure lpeInt16_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PCurrency(Right)^; end;
-procedure lpeInt16_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PExtended(Right)^; end;
-procedure lpeInt16_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ = PVariant(Right)^; end;
-procedure lpeUInt32_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PUInt8(Right)^; end;
-procedure lpeUInt32_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PInt8(Right)^; end;
-procedure lpeUInt32_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PUInt16(Right)^; end;
-procedure lpeUInt32_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PInt16(Right)^; end;
-procedure lpeUInt32_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PUInt32(Right)^; end;
-procedure lpeUInt32_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PInt32(Right)^; end;
-procedure lpeUInt32_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PUInt64(Right)^; end;
-procedure lpeUInt32_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PInt64(Right)^; end;
-procedure lpeUInt32_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PSingle(Right)^; end;
-procedure lpeUInt32_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PDouble(Right)^; end;
-procedure lpeUInt32_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PCurrency(Right)^; end;
-procedure lpeUInt32_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PExtended(Right)^; end;
-procedure lpeUInt32_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ = PVariant(Right)^; end;
-procedure lpeInt32_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PUInt8(Right)^; end;
-procedure lpeInt32_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PInt8(Right)^; end;
-procedure lpeInt32_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PUInt16(Right)^; end;
-procedure lpeInt32_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PInt16(Right)^; end;
-procedure lpeInt32_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PUInt32(Right)^; end;
-procedure lpeInt32_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PInt32(Right)^; end;
-procedure lpeInt32_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PUInt64(Right)^; end;
-procedure lpeInt32_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PInt64(Right)^; end;
-procedure lpeInt32_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PSingle(Right)^; end;
-procedure lpeInt32_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PDouble(Right)^; end;
-procedure lpeInt32_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PCurrency(Right)^; end;
-procedure lpeInt32_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PExtended(Right)^; end;
-procedure lpeInt32_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ = PVariant(Right)^; end;
-procedure lpeUInt64_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PUInt8(Right)^; end;
-procedure lpeUInt64_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PInt8(Right)^; end;
-procedure lpeUInt64_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PUInt16(Right)^; end;
-procedure lpeUInt64_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PInt16(Right)^; end;
-procedure lpeUInt64_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PUInt32(Right)^; end;
-procedure lpeUInt64_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PInt32(Right)^; end;
-procedure lpeUInt64_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PUInt64(Right)^; end;
-procedure lpeUInt64_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PInt64(Right)^; end;
-procedure lpeUInt64_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PSingle(Right)^; end;
-procedure lpeUInt64_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PDouble(Right)^; end;
-procedure lpeUInt64_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PCurrency(Right)^; end;
-procedure lpeUInt64_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PExtended(Right)^; end;
-procedure lpeUInt64_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ = PVariant(Right)^; end;
-procedure lpeInt64_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PUInt8(Right)^; end;
-procedure lpeInt64_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PInt8(Right)^; end;
-procedure lpeInt64_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PUInt16(Right)^; end;
-procedure lpeInt64_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PInt16(Right)^; end;
-procedure lpeInt64_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PUInt32(Right)^; end;
-procedure lpeInt64_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PInt32(Right)^; end;
-procedure lpeInt64_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PUInt64(Right)^; end;
-procedure lpeInt64_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PInt64(Right)^; end;
-procedure lpeInt64_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PSingle(Right)^; end;
-procedure lpeInt64_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PDouble(Right)^; end;
-procedure lpeInt64_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PCurrency(Right)^; end;
-procedure lpeInt64_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PExtended(Right)^; end;
-procedure lpeInt64_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ = PVariant(Right)^; end;
-procedure lpeSingle_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PUInt8(Right)^; end;
-procedure lpeSingle_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PInt8(Right)^; end;
-procedure lpeSingle_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PUInt16(Right)^; end;
-procedure lpeSingle_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PInt16(Right)^; end;
-procedure lpeSingle_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PUInt32(Right)^; end;
-procedure lpeSingle_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PInt32(Right)^; end;
-procedure lpeSingle_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PUInt64(Right)^; end;
-procedure lpeSingle_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PInt64(Right)^; end;
-procedure lpeSingle_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PSingle(Right)^; end;
-procedure lpeSingle_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PDouble(Right)^; end;
-procedure lpeSingle_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PCurrency(Right)^; end;
-procedure lpeSingle_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PExtended(Right)^; end;
-procedure lpeSingle_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ = PVariant(Right)^; end;
-procedure lpeDouble_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PUInt8(Right)^; end;
-procedure lpeDouble_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PInt8(Right)^; end;
-procedure lpeDouble_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PUInt16(Right)^; end;
-procedure lpeDouble_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PInt16(Right)^; end;
-procedure lpeDouble_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PUInt32(Right)^; end;
-procedure lpeDouble_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PInt32(Right)^; end;
-procedure lpeDouble_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PUInt64(Right)^; end;
-procedure lpeDouble_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PInt64(Right)^; end;
-procedure lpeDouble_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PSingle(Right)^; end;
-procedure lpeDouble_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PDouble(Right)^; end;
-procedure lpeDouble_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PCurrency(Right)^; end;
-procedure lpeDouble_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PExtended(Right)^; end;
-procedure lpeDouble_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ = PVariant(Right)^; end;
-procedure lpeCurrency_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PUInt8(Right)^; end;
-procedure lpeCurrency_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PInt8(Right)^; end;
-procedure lpeCurrency_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PUInt16(Right)^; end;
-procedure lpeCurrency_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PInt16(Right)^; end;
-procedure lpeCurrency_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PUInt32(Right)^; end;
-procedure lpeCurrency_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PInt32(Right)^; end;
-procedure lpeCurrency_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PUInt64(Right)^; end;
-procedure lpeCurrency_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PInt64(Right)^; end;
-procedure lpeCurrency_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PSingle(Right)^; end;
-procedure lpeCurrency_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PDouble(Right)^; end;
-procedure lpeCurrency_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PCurrency(Right)^; end;
-procedure lpeCurrency_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PExtended(Right)^; end;
-procedure lpeCurrency_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ = PVariant(Right)^; end;
-procedure lpeExtended_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PUInt8(Right)^; end;
-procedure lpeExtended_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PInt8(Right)^; end;
-procedure lpeExtended_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PUInt16(Right)^; end;
-procedure lpeExtended_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PInt16(Right)^; end;
-procedure lpeExtended_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PUInt32(Right)^; end;
-procedure lpeExtended_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PInt32(Right)^; end;
-procedure lpeExtended_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PUInt64(Right)^; end;
-procedure lpeExtended_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PInt64(Right)^; end;
-procedure lpeExtended_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PSingle(Right)^; end;
-procedure lpeExtended_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PDouble(Right)^; end;
-procedure lpeExtended_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PCurrency(Right)^; end;
-procedure lpeExtended_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PExtended(Right)^; end;
-procedure lpeExtended_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ = PVariant(Right)^; end;
-procedure lpeVariant_EQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PUInt8(Right)^; end;
-procedure lpeVariant_EQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PInt8(Right)^; end;
-procedure lpeVariant_EQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PUInt16(Right)^; end;
-procedure lpeVariant_EQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PInt16(Right)^; end;
-procedure lpeVariant_EQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PUInt32(Right)^; end;
-procedure lpeVariant_EQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PInt32(Right)^; end;
-procedure lpeVariant_EQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PUInt64(Right)^; end;
-procedure lpeVariant_EQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PInt64(Right)^; end;
-procedure lpeVariant_EQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PSingle(Right)^; end;
-procedure lpeVariant_EQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PDouble(Right)^; end;
-procedure lpeVariant_EQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PCurrency(Right)^; end;
-procedure lpeVariant_EQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PExtended(Right)^; end;
-procedure lpeVariant_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ = PVariant(Right)^; end;
-procedure lpeUInt8_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PUInt8(Right)^; end;
-procedure lpeUInt8_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PInt8(Right)^; end;
-procedure lpeUInt8_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PUInt16(Right)^; end;
-procedure lpeUInt8_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PInt16(Right)^; end;
-procedure lpeUInt8_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PUInt32(Right)^; end;
-procedure lpeUInt8_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PInt32(Right)^; end;
-procedure lpeUInt8_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PUInt64(Right)^; end;
-procedure lpeUInt8_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PInt64(Right)^; end;
-procedure lpeUInt8_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PSingle(Right)^; end;
-procedure lpeUInt8_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PDouble(Right)^; end;
-procedure lpeUInt8_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PCurrency(Right)^; end;
-procedure lpeUInt8_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PExtended(Right)^; end;
-procedure lpeUInt8_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ > PVariant(Right)^; end;
-procedure lpeInt8_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PUInt8(Right)^; end;
-procedure lpeInt8_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PInt8(Right)^; end;
-procedure lpeInt8_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PUInt16(Right)^; end;
-procedure lpeInt8_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PInt16(Right)^; end;
-procedure lpeInt8_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PUInt32(Right)^; end;
-procedure lpeInt8_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PInt32(Right)^; end;
-procedure lpeInt8_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PUInt64(Right)^; end;
-procedure lpeInt8_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PInt64(Right)^; end;
-procedure lpeInt8_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PSingle(Right)^; end;
-procedure lpeInt8_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PDouble(Right)^; end;
-procedure lpeInt8_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PCurrency(Right)^; end;
-procedure lpeInt8_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PExtended(Right)^; end;
-procedure lpeInt8_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ > PVariant(Right)^; end;
-procedure lpeUInt16_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PUInt8(Right)^; end;
-procedure lpeUInt16_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PInt8(Right)^; end;
-procedure lpeUInt16_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PUInt16(Right)^; end;
-procedure lpeUInt16_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PInt16(Right)^; end;
-procedure lpeUInt16_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PUInt32(Right)^; end;
-procedure lpeUInt16_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PInt32(Right)^; end;
-procedure lpeUInt16_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PUInt64(Right)^; end;
-procedure lpeUInt16_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PInt64(Right)^; end;
-procedure lpeUInt16_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PSingle(Right)^; end;
-procedure lpeUInt16_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PDouble(Right)^; end;
-procedure lpeUInt16_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PCurrency(Right)^; end;
-procedure lpeUInt16_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PExtended(Right)^; end;
-procedure lpeUInt16_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ > PVariant(Right)^; end;
-procedure lpeInt16_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PUInt8(Right)^; end;
-procedure lpeInt16_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PInt8(Right)^; end;
-procedure lpeInt16_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PUInt16(Right)^; end;
-procedure lpeInt16_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PInt16(Right)^; end;
-procedure lpeInt16_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PUInt32(Right)^; end;
-procedure lpeInt16_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PInt32(Right)^; end;
-procedure lpeInt16_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PUInt64(Right)^; end;
-procedure lpeInt16_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PInt64(Right)^; end;
-procedure lpeInt16_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PSingle(Right)^; end;
-procedure lpeInt16_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PDouble(Right)^; end;
-procedure lpeInt16_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PCurrency(Right)^; end;
-procedure lpeInt16_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PExtended(Right)^; end;
-procedure lpeInt16_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ > PVariant(Right)^; end;
-procedure lpeUInt32_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PUInt8(Right)^; end;
-procedure lpeUInt32_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PInt8(Right)^; end;
-procedure lpeUInt32_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PUInt16(Right)^; end;
-procedure lpeUInt32_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PInt16(Right)^; end;
-procedure lpeUInt32_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PUInt32(Right)^; end;
-procedure lpeUInt32_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PInt32(Right)^; end;
-procedure lpeUInt32_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PUInt64(Right)^; end;
-procedure lpeUInt32_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PInt64(Right)^; end;
-procedure lpeUInt32_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PSingle(Right)^; end;
-procedure lpeUInt32_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PDouble(Right)^; end;
-procedure lpeUInt32_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PCurrency(Right)^; end;
-procedure lpeUInt32_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PExtended(Right)^; end;
-procedure lpeUInt32_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ > PVariant(Right)^; end;
-procedure lpeInt32_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PUInt8(Right)^; end;
-procedure lpeInt32_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PInt8(Right)^; end;
-procedure lpeInt32_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PUInt16(Right)^; end;
-procedure lpeInt32_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PInt16(Right)^; end;
-procedure lpeInt32_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PUInt32(Right)^; end;
-procedure lpeInt32_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PInt32(Right)^; end;
-procedure lpeInt32_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PUInt64(Right)^; end;
-procedure lpeInt32_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PInt64(Right)^; end;
-procedure lpeInt32_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PSingle(Right)^; end;
-procedure lpeInt32_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PDouble(Right)^; end;
-procedure lpeInt32_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PCurrency(Right)^; end;
-procedure lpeInt32_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PExtended(Right)^; end;
-procedure lpeInt32_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ > PVariant(Right)^; end;
-procedure lpeUInt64_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PUInt8(Right)^; end;
-procedure lpeUInt64_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PInt8(Right)^; end;
-procedure lpeUInt64_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PUInt16(Right)^; end;
-procedure lpeUInt64_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PInt16(Right)^; end;
-procedure lpeUInt64_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PUInt32(Right)^; end;
-procedure lpeUInt64_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PInt32(Right)^; end;
-procedure lpeUInt64_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PUInt64(Right)^; end;
-procedure lpeUInt64_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PInt64(Right)^; end;
-procedure lpeUInt64_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PSingle(Right)^; end;
-procedure lpeUInt64_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PDouble(Right)^; end;
-procedure lpeUInt64_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PCurrency(Right)^; end;
-procedure lpeUInt64_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PExtended(Right)^; end;
-procedure lpeUInt64_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ > PVariant(Right)^; end;
-procedure lpeInt64_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PUInt8(Right)^; end;
-procedure lpeInt64_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PInt8(Right)^; end;
-procedure lpeInt64_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PUInt16(Right)^; end;
-procedure lpeInt64_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PInt16(Right)^; end;
-procedure lpeInt64_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PUInt32(Right)^; end;
-procedure lpeInt64_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PInt32(Right)^; end;
-procedure lpeInt64_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PUInt64(Right)^; end;
-procedure lpeInt64_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PInt64(Right)^; end;
-procedure lpeInt64_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PSingle(Right)^; end;
-procedure lpeInt64_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PDouble(Right)^; end;
-procedure lpeInt64_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PCurrency(Right)^; end;
-procedure lpeInt64_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PExtended(Right)^; end;
-procedure lpeInt64_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ > PVariant(Right)^; end;
-procedure lpeSingle_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PUInt8(Right)^; end;
-procedure lpeSingle_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PInt8(Right)^; end;
-procedure lpeSingle_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PUInt16(Right)^; end;
-procedure lpeSingle_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PInt16(Right)^; end;
-procedure lpeSingle_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PUInt32(Right)^; end;
-procedure lpeSingle_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PInt32(Right)^; end;
-procedure lpeSingle_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PUInt64(Right)^; end;
-procedure lpeSingle_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PInt64(Right)^; end;
-procedure lpeSingle_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PSingle(Right)^; end;
-procedure lpeSingle_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PDouble(Right)^; end;
-procedure lpeSingle_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PCurrency(Right)^; end;
-procedure lpeSingle_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PExtended(Right)^; end;
-procedure lpeSingle_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ > PVariant(Right)^; end;
-procedure lpeDouble_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PUInt8(Right)^; end;
-procedure lpeDouble_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PInt8(Right)^; end;
-procedure lpeDouble_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PUInt16(Right)^; end;
-procedure lpeDouble_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PInt16(Right)^; end;
-procedure lpeDouble_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PUInt32(Right)^; end;
-procedure lpeDouble_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PInt32(Right)^; end;
-procedure lpeDouble_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PUInt64(Right)^; end;
-procedure lpeDouble_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PInt64(Right)^; end;
-procedure lpeDouble_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PSingle(Right)^; end;
-procedure lpeDouble_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PDouble(Right)^; end;
-procedure lpeDouble_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PCurrency(Right)^; end;
-procedure lpeDouble_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PExtended(Right)^; end;
-procedure lpeDouble_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ > PVariant(Right)^; end;
-procedure lpeCurrency_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PUInt8(Right)^; end;
-procedure lpeCurrency_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PInt8(Right)^; end;
-procedure lpeCurrency_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PUInt16(Right)^; end;
-procedure lpeCurrency_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PInt16(Right)^; end;
-procedure lpeCurrency_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PUInt32(Right)^; end;
-procedure lpeCurrency_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PInt32(Right)^; end;
-procedure lpeCurrency_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PUInt64(Right)^; end;
-procedure lpeCurrency_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PInt64(Right)^; end;
-procedure lpeCurrency_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PSingle(Right)^; end;
-procedure lpeCurrency_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PDouble(Right)^; end;
-procedure lpeCurrency_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PCurrency(Right)^; end;
-procedure lpeCurrency_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PExtended(Right)^; end;
-procedure lpeCurrency_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ > PVariant(Right)^; end;
-procedure lpeExtended_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PUInt8(Right)^; end;
-procedure lpeExtended_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PInt8(Right)^; end;
-procedure lpeExtended_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PUInt16(Right)^; end;
-procedure lpeExtended_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PInt16(Right)^; end;
-procedure lpeExtended_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PUInt32(Right)^; end;
-procedure lpeExtended_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PInt32(Right)^; end;
-procedure lpeExtended_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PUInt64(Right)^; end;
-procedure lpeExtended_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PInt64(Right)^; end;
-procedure lpeExtended_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PSingle(Right)^; end;
-procedure lpeExtended_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PDouble(Right)^; end;
-procedure lpeExtended_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PCurrency(Right)^; end;
-procedure lpeExtended_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PExtended(Right)^; end;
-procedure lpeExtended_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ > PVariant(Right)^; end;
-procedure lpeVariant_GT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PUInt8(Right)^; end;
-procedure lpeVariant_GT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PInt8(Right)^; end;
-procedure lpeVariant_GT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PUInt16(Right)^; end;
-procedure lpeVariant_GT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PInt16(Right)^; end;
-procedure lpeVariant_GT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PUInt32(Right)^; end;
-procedure lpeVariant_GT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PInt32(Right)^; end;
-procedure lpeVariant_GT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PUInt64(Right)^; end;
-procedure lpeVariant_GT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PInt64(Right)^; end;
-procedure lpeVariant_GT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PSingle(Right)^; end;
-procedure lpeVariant_GT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PDouble(Right)^; end;
-procedure lpeVariant_GT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PCurrency(Right)^; end;
-procedure lpeVariant_GT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PExtended(Right)^; end;
-procedure lpeVariant_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ > PVariant(Right)^; end;
-procedure lpeUInt8_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PUInt8(Right)^; end;
-procedure lpeUInt8_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PInt8(Right)^; end;
-procedure lpeUInt8_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PUInt16(Right)^; end;
-procedure lpeUInt8_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PInt16(Right)^; end;
-procedure lpeUInt8_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PUInt32(Right)^; end;
-procedure lpeUInt8_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PInt32(Right)^; end;
-procedure lpeUInt8_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PUInt64(Right)^; end;
-procedure lpeUInt8_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PInt64(Right)^; end;
-procedure lpeUInt8_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PSingle(Right)^; end;
-procedure lpeUInt8_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PDouble(Right)^; end;
-procedure lpeUInt8_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PCurrency(Right)^; end;
-procedure lpeUInt8_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PExtended(Right)^; end;
-procedure lpeUInt8_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PVariant(Right)^; end;
-procedure lpeInt8_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PUInt8(Right)^; end;
-procedure lpeInt8_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PInt8(Right)^; end;
-procedure lpeInt8_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PUInt16(Right)^; end;
-procedure lpeInt8_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PInt16(Right)^; end;
-procedure lpeInt8_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PUInt32(Right)^; end;
-procedure lpeInt8_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PInt32(Right)^; end;
-procedure lpeInt8_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PUInt64(Right)^; end;
-procedure lpeInt8_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PInt64(Right)^; end;
-procedure lpeInt8_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PSingle(Right)^; end;
-procedure lpeInt8_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PDouble(Right)^; end;
-procedure lpeInt8_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PCurrency(Right)^; end;
-procedure lpeInt8_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PExtended(Right)^; end;
-procedure lpeInt8_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ >= PVariant(Right)^; end;
-procedure lpeUInt16_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PUInt8(Right)^; end;
-procedure lpeUInt16_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PInt8(Right)^; end;
-procedure lpeUInt16_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PUInt16(Right)^; end;
-procedure lpeUInt16_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PInt16(Right)^; end;
-procedure lpeUInt16_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PUInt32(Right)^; end;
-procedure lpeUInt16_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PInt32(Right)^; end;
-procedure lpeUInt16_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PUInt64(Right)^; end;
-procedure lpeUInt16_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PInt64(Right)^; end;
-procedure lpeUInt16_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PSingle(Right)^; end;
-procedure lpeUInt16_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PDouble(Right)^; end;
-procedure lpeUInt16_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PCurrency(Right)^; end;
-procedure lpeUInt16_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PExtended(Right)^; end;
-procedure lpeUInt16_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PVariant(Right)^; end;
-procedure lpeInt16_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PUInt8(Right)^; end;
-procedure lpeInt16_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PInt8(Right)^; end;
-procedure lpeInt16_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PUInt16(Right)^; end;
-procedure lpeInt16_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PInt16(Right)^; end;
-procedure lpeInt16_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PUInt32(Right)^; end;
-procedure lpeInt16_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PInt32(Right)^; end;
-procedure lpeInt16_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PUInt64(Right)^; end;
-procedure lpeInt16_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PInt64(Right)^; end;
-procedure lpeInt16_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PSingle(Right)^; end;
-procedure lpeInt16_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PDouble(Right)^; end;
-procedure lpeInt16_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PCurrency(Right)^; end;
-procedure lpeInt16_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PExtended(Right)^; end;
-procedure lpeInt16_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ >= PVariant(Right)^; end;
-procedure lpeUInt32_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PUInt8(Right)^; end;
-procedure lpeUInt32_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PInt8(Right)^; end;
-procedure lpeUInt32_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PUInt16(Right)^; end;
-procedure lpeUInt32_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PInt16(Right)^; end;
-procedure lpeUInt32_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PUInt32(Right)^; end;
-procedure lpeUInt32_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PInt32(Right)^; end;
-procedure lpeUInt32_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PUInt64(Right)^; end;
-procedure lpeUInt32_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PInt64(Right)^; end;
-procedure lpeUInt32_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PSingle(Right)^; end;
-procedure lpeUInt32_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PDouble(Right)^; end;
-procedure lpeUInt32_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PCurrency(Right)^; end;
-procedure lpeUInt32_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PExtended(Right)^; end;
-procedure lpeUInt32_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PVariant(Right)^; end;
-procedure lpeInt32_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PUInt8(Right)^; end;
-procedure lpeInt32_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PInt8(Right)^; end;
-procedure lpeInt32_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PUInt16(Right)^; end;
-procedure lpeInt32_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PInt16(Right)^; end;
-procedure lpeInt32_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PUInt32(Right)^; end;
-procedure lpeInt32_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PInt32(Right)^; end;
-procedure lpeInt32_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PUInt64(Right)^; end;
-procedure lpeInt32_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PInt64(Right)^; end;
-procedure lpeInt32_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PSingle(Right)^; end;
-procedure lpeInt32_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PDouble(Right)^; end;
-procedure lpeInt32_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PCurrency(Right)^; end;
-procedure lpeInt32_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PExtended(Right)^; end;
-procedure lpeInt32_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ >= PVariant(Right)^; end;
-procedure lpeUInt64_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PUInt8(Right)^; end;
-procedure lpeUInt64_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PInt8(Right)^; end;
-procedure lpeUInt64_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PUInt16(Right)^; end;
-procedure lpeUInt64_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PInt16(Right)^; end;
-procedure lpeUInt64_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PUInt32(Right)^; end;
-procedure lpeUInt64_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PInt32(Right)^; end;
-procedure lpeUInt64_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PUInt64(Right)^; end;
-procedure lpeUInt64_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PInt64(Right)^; end;
-procedure lpeUInt64_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PSingle(Right)^; end;
-procedure lpeUInt64_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PDouble(Right)^; end;
-procedure lpeUInt64_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PCurrency(Right)^; end;
-procedure lpeUInt64_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PExtended(Right)^; end;
-procedure lpeUInt64_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PVariant(Right)^; end;
-procedure lpeInt64_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PUInt8(Right)^; end;
-procedure lpeInt64_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PInt8(Right)^; end;
-procedure lpeInt64_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PUInt16(Right)^; end;
-procedure lpeInt64_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PInt16(Right)^; end;
-procedure lpeInt64_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PUInt32(Right)^; end;
-procedure lpeInt64_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PInt32(Right)^; end;
-procedure lpeInt64_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PUInt64(Right)^; end;
-procedure lpeInt64_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PInt64(Right)^; end;
-procedure lpeInt64_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PSingle(Right)^; end;
-procedure lpeInt64_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PDouble(Right)^; end;
-procedure lpeInt64_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PCurrency(Right)^; end;
-procedure lpeInt64_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PExtended(Right)^; end;
-procedure lpeInt64_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ >= PVariant(Right)^; end;
-procedure lpeSingle_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PUInt8(Right)^; end;
-procedure lpeSingle_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PInt8(Right)^; end;
-procedure lpeSingle_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PUInt16(Right)^; end;
-procedure lpeSingle_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PInt16(Right)^; end;
-procedure lpeSingle_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PUInt32(Right)^; end;
-procedure lpeSingle_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PInt32(Right)^; end;
-procedure lpeSingle_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PUInt64(Right)^; end;
-procedure lpeSingle_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PInt64(Right)^; end;
-procedure lpeSingle_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PSingle(Right)^; end;
-procedure lpeSingle_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PDouble(Right)^; end;
-procedure lpeSingle_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PCurrency(Right)^; end;
-procedure lpeSingle_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PExtended(Right)^; end;
-procedure lpeSingle_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ >= PVariant(Right)^; end;
-procedure lpeDouble_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PUInt8(Right)^; end;
-procedure lpeDouble_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PInt8(Right)^; end;
-procedure lpeDouble_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PUInt16(Right)^; end;
-procedure lpeDouble_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PInt16(Right)^; end;
-procedure lpeDouble_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PUInt32(Right)^; end;
-procedure lpeDouble_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PInt32(Right)^; end;
-procedure lpeDouble_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PUInt64(Right)^; end;
-procedure lpeDouble_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PInt64(Right)^; end;
-procedure lpeDouble_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PSingle(Right)^; end;
-procedure lpeDouble_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PDouble(Right)^; end;
-procedure lpeDouble_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PCurrency(Right)^; end;
-procedure lpeDouble_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PExtended(Right)^; end;
-procedure lpeDouble_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ >= PVariant(Right)^; end;
-procedure lpeCurrency_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PUInt8(Right)^; end;
-procedure lpeCurrency_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PInt8(Right)^; end;
-procedure lpeCurrency_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PUInt16(Right)^; end;
-procedure lpeCurrency_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PInt16(Right)^; end;
-procedure lpeCurrency_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PUInt32(Right)^; end;
-procedure lpeCurrency_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PInt32(Right)^; end;
-procedure lpeCurrency_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PUInt64(Right)^; end;
-procedure lpeCurrency_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PInt64(Right)^; end;
-procedure lpeCurrency_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PSingle(Right)^; end;
-procedure lpeCurrency_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PDouble(Right)^; end;
-procedure lpeCurrency_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PCurrency(Right)^; end;
-procedure lpeCurrency_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PExtended(Right)^; end;
-procedure lpeCurrency_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PVariant(Right)^; end;
-procedure lpeExtended_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PUInt8(Right)^; end;
-procedure lpeExtended_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PInt8(Right)^; end;
-procedure lpeExtended_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PUInt16(Right)^; end;
-procedure lpeExtended_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PInt16(Right)^; end;
-procedure lpeExtended_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PUInt32(Right)^; end;
-procedure lpeExtended_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PInt32(Right)^; end;
-procedure lpeExtended_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PUInt64(Right)^; end;
-procedure lpeExtended_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PInt64(Right)^; end;
-procedure lpeExtended_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PSingle(Right)^; end;
-procedure lpeExtended_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PDouble(Right)^; end;
-procedure lpeExtended_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PCurrency(Right)^; end;
-procedure lpeExtended_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PExtended(Right)^; end;
-procedure lpeExtended_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ >= PVariant(Right)^; end;
-procedure lpeVariant_GTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PUInt8(Right)^; end;
-procedure lpeVariant_GTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PInt8(Right)^; end;
-procedure lpeVariant_GTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PUInt16(Right)^; end;
-procedure lpeVariant_GTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PInt16(Right)^; end;
-procedure lpeVariant_GTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PUInt32(Right)^; end;
-procedure lpeVariant_GTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PInt32(Right)^; end;
-procedure lpeVariant_GTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PUInt64(Right)^; end;
-procedure lpeVariant_GTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PInt64(Right)^; end;
-procedure lpeVariant_GTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PSingle(Right)^; end;
-procedure lpeVariant_GTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PDouble(Right)^; end;
-procedure lpeVariant_GTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PCurrency(Right)^; end;
-procedure lpeVariant_GTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PExtended(Right)^; end;
-procedure lpeVariant_GTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ >= PVariant(Right)^; end;
-procedure lpeUInt8_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PUInt8(Right)^; end;
-procedure lpeUInt8_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PInt8(Right)^; end;
-procedure lpeUInt8_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PUInt16(Right)^; end;
-procedure lpeUInt8_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PInt16(Right)^; end;
-procedure lpeUInt8_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PUInt32(Right)^; end;
-procedure lpeUInt8_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PInt32(Right)^; end;
-procedure lpeUInt8_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PUInt64(Right)^; end;
-procedure lpeUInt8_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PInt64(Right)^; end;
-procedure lpeUInt8_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PSingle(Right)^; end;
-procedure lpeUInt8_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PDouble(Right)^; end;
-procedure lpeUInt8_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PCurrency(Right)^; end;
-procedure lpeUInt8_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PExtended(Right)^; end;
-procedure lpeUInt8_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ < PVariant(Right)^; end;
-procedure lpeInt8_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PUInt8(Right)^; end;
-procedure lpeInt8_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PInt8(Right)^; end;
-procedure lpeInt8_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PUInt16(Right)^; end;
-procedure lpeInt8_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PInt16(Right)^; end;
-procedure lpeInt8_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PUInt32(Right)^; end;
-procedure lpeInt8_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PInt32(Right)^; end;
-procedure lpeInt8_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PUInt64(Right)^; end;
-procedure lpeInt8_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PInt64(Right)^; end;
-procedure lpeInt8_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PSingle(Right)^; end;
-procedure lpeInt8_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PDouble(Right)^; end;
-procedure lpeInt8_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PCurrency(Right)^; end;
-procedure lpeInt8_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PExtended(Right)^; end;
-procedure lpeInt8_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ < PVariant(Right)^; end;
-procedure lpeUInt16_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PUInt8(Right)^; end;
-procedure lpeUInt16_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PInt8(Right)^; end;
-procedure lpeUInt16_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PUInt16(Right)^; end;
-procedure lpeUInt16_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PInt16(Right)^; end;
-procedure lpeUInt16_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PUInt32(Right)^; end;
-procedure lpeUInt16_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PInt32(Right)^; end;
-procedure lpeUInt16_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PUInt64(Right)^; end;
-procedure lpeUInt16_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PInt64(Right)^; end;
-procedure lpeUInt16_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PSingle(Right)^; end;
-procedure lpeUInt16_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PDouble(Right)^; end;
-procedure lpeUInt16_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PCurrency(Right)^; end;
-procedure lpeUInt16_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PExtended(Right)^; end;
-procedure lpeUInt16_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ < PVariant(Right)^; end;
-procedure lpeInt16_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PUInt8(Right)^; end;
-procedure lpeInt16_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PInt8(Right)^; end;
-procedure lpeInt16_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PUInt16(Right)^; end;
-procedure lpeInt16_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PInt16(Right)^; end;
-procedure lpeInt16_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PUInt32(Right)^; end;
-procedure lpeInt16_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PInt32(Right)^; end;
-procedure lpeInt16_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PUInt64(Right)^; end;
-procedure lpeInt16_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PInt64(Right)^; end;
-procedure lpeInt16_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PSingle(Right)^; end;
-procedure lpeInt16_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PDouble(Right)^; end;
-procedure lpeInt16_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PCurrency(Right)^; end;
-procedure lpeInt16_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PExtended(Right)^; end;
-procedure lpeInt16_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ < PVariant(Right)^; end;
-procedure lpeUInt32_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PUInt8(Right)^; end;
-procedure lpeUInt32_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PInt8(Right)^; end;
-procedure lpeUInt32_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PUInt16(Right)^; end;
-procedure lpeUInt32_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PInt16(Right)^; end;
-procedure lpeUInt32_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PUInt32(Right)^; end;
-procedure lpeUInt32_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PInt32(Right)^; end;
-procedure lpeUInt32_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PUInt64(Right)^; end;
-procedure lpeUInt32_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PInt64(Right)^; end;
-procedure lpeUInt32_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PSingle(Right)^; end;
-procedure lpeUInt32_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PDouble(Right)^; end;
-procedure lpeUInt32_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PCurrency(Right)^; end;
-procedure lpeUInt32_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PExtended(Right)^; end;
-procedure lpeUInt32_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ < PVariant(Right)^; end;
-procedure lpeInt32_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PUInt8(Right)^; end;
-procedure lpeInt32_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PInt8(Right)^; end;
-procedure lpeInt32_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PUInt16(Right)^; end;
-procedure lpeInt32_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PInt16(Right)^; end;
-procedure lpeInt32_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PUInt32(Right)^; end;
-procedure lpeInt32_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PInt32(Right)^; end;
-procedure lpeInt32_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PUInt64(Right)^; end;
-procedure lpeInt32_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PInt64(Right)^; end;
-procedure lpeInt32_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PSingle(Right)^; end;
-procedure lpeInt32_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PDouble(Right)^; end;
-procedure lpeInt32_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PCurrency(Right)^; end;
-procedure lpeInt32_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PExtended(Right)^; end;
-procedure lpeInt32_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ < PVariant(Right)^; end;
-procedure lpeUInt64_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PUInt8(Right)^; end;
-procedure lpeUInt64_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PInt8(Right)^; end;
-procedure lpeUInt64_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PUInt16(Right)^; end;
-procedure lpeUInt64_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PInt16(Right)^; end;
-procedure lpeUInt64_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PUInt32(Right)^; end;
-procedure lpeUInt64_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PInt32(Right)^; end;
-procedure lpeUInt64_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PUInt64(Right)^; end;
-procedure lpeUInt64_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PInt64(Right)^; end;
-procedure lpeUInt64_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PSingle(Right)^; end;
-procedure lpeUInt64_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PDouble(Right)^; end;
-procedure lpeUInt64_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PCurrency(Right)^; end;
-procedure lpeUInt64_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PExtended(Right)^; end;
-procedure lpeUInt64_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ < PVariant(Right)^; end;
-procedure lpeInt64_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PUInt8(Right)^; end;
-procedure lpeInt64_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PInt8(Right)^; end;
-procedure lpeInt64_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PUInt16(Right)^; end;
-procedure lpeInt64_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PInt16(Right)^; end;
-procedure lpeInt64_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PUInt32(Right)^; end;
-procedure lpeInt64_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PInt32(Right)^; end;
-procedure lpeInt64_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PUInt64(Right)^; end;
-procedure lpeInt64_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PInt64(Right)^; end;
-procedure lpeInt64_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PSingle(Right)^; end;
-procedure lpeInt64_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PDouble(Right)^; end;
-procedure lpeInt64_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PCurrency(Right)^; end;
-procedure lpeInt64_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PExtended(Right)^; end;
-procedure lpeInt64_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ < PVariant(Right)^; end;
-procedure lpeSingle_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PUInt8(Right)^; end;
-procedure lpeSingle_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PInt8(Right)^; end;
-procedure lpeSingle_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PUInt16(Right)^; end;
-procedure lpeSingle_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PInt16(Right)^; end;
-procedure lpeSingle_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PUInt32(Right)^; end;
-procedure lpeSingle_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PInt32(Right)^; end;
-procedure lpeSingle_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PUInt64(Right)^; end;
-procedure lpeSingle_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PInt64(Right)^; end;
-procedure lpeSingle_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PSingle(Right)^; end;
-procedure lpeSingle_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PDouble(Right)^; end;
-procedure lpeSingle_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PCurrency(Right)^; end;
-procedure lpeSingle_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PExtended(Right)^; end;
-procedure lpeSingle_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ < PVariant(Right)^; end;
-procedure lpeDouble_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PUInt8(Right)^; end;
-procedure lpeDouble_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PInt8(Right)^; end;
-procedure lpeDouble_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PUInt16(Right)^; end;
-procedure lpeDouble_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PInt16(Right)^; end;
-procedure lpeDouble_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PUInt32(Right)^; end;
-procedure lpeDouble_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PInt32(Right)^; end;
-procedure lpeDouble_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PUInt64(Right)^; end;
-procedure lpeDouble_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PInt64(Right)^; end;
-procedure lpeDouble_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PSingle(Right)^; end;
-procedure lpeDouble_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PDouble(Right)^; end;
-procedure lpeDouble_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PCurrency(Right)^; end;
-procedure lpeDouble_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PExtended(Right)^; end;
-procedure lpeDouble_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ < PVariant(Right)^; end;
-procedure lpeCurrency_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PUInt8(Right)^; end;
-procedure lpeCurrency_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PInt8(Right)^; end;
-procedure lpeCurrency_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PUInt16(Right)^; end;
-procedure lpeCurrency_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PInt16(Right)^; end;
-procedure lpeCurrency_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PUInt32(Right)^; end;
-procedure lpeCurrency_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PInt32(Right)^; end;
-procedure lpeCurrency_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PUInt64(Right)^; end;
-procedure lpeCurrency_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PInt64(Right)^; end;
-procedure lpeCurrency_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PSingle(Right)^; end;
-procedure lpeCurrency_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PDouble(Right)^; end;
-procedure lpeCurrency_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PCurrency(Right)^; end;
-procedure lpeCurrency_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PExtended(Right)^; end;
-procedure lpeCurrency_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ < PVariant(Right)^; end;
-procedure lpeExtended_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PUInt8(Right)^; end;
-procedure lpeExtended_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PInt8(Right)^; end;
-procedure lpeExtended_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PUInt16(Right)^; end;
-procedure lpeExtended_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PInt16(Right)^; end;
-procedure lpeExtended_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PUInt32(Right)^; end;
-procedure lpeExtended_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PInt32(Right)^; end;
-procedure lpeExtended_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PUInt64(Right)^; end;
-procedure lpeExtended_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PInt64(Right)^; end;
-procedure lpeExtended_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PSingle(Right)^; end;
-procedure lpeExtended_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PDouble(Right)^; end;
-procedure lpeExtended_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PCurrency(Right)^; end;
-procedure lpeExtended_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PExtended(Right)^; end;
-procedure lpeExtended_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ < PVariant(Right)^; end;
-procedure lpeVariant_LT_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PUInt8(Right)^; end;
-procedure lpeVariant_LT_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PInt8(Right)^; end;
-procedure lpeVariant_LT_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PUInt16(Right)^; end;
-procedure lpeVariant_LT_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PInt16(Right)^; end;
-procedure lpeVariant_LT_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PUInt32(Right)^; end;
-procedure lpeVariant_LT_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PInt32(Right)^; end;
-procedure lpeVariant_LT_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PUInt64(Right)^; end;
-procedure lpeVariant_LT_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PInt64(Right)^; end;
-procedure lpeVariant_LT_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PSingle(Right)^; end;
-procedure lpeVariant_LT_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PDouble(Right)^; end;
-procedure lpeVariant_LT_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PCurrency(Right)^; end;
-procedure lpeVariant_LT_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PExtended(Right)^; end;
-procedure lpeVariant_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ < PVariant(Right)^; end;
-procedure lpeUInt8_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PUInt8(Right)^; end;
-procedure lpeUInt8_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PInt8(Right)^; end;
-procedure lpeUInt8_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PUInt16(Right)^; end;
-procedure lpeUInt8_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PInt16(Right)^; end;
-procedure lpeUInt8_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PUInt32(Right)^; end;
-procedure lpeUInt8_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PInt32(Right)^; end;
-procedure lpeUInt8_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PUInt64(Right)^; end;
-procedure lpeUInt8_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PInt64(Right)^; end;
-procedure lpeUInt8_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PSingle(Right)^; end;
-procedure lpeUInt8_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PDouble(Right)^; end;
-procedure lpeUInt8_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PCurrency(Right)^; end;
-procedure lpeUInt8_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PExtended(Right)^; end;
-procedure lpeUInt8_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PVariant(Right)^; end;
-procedure lpeInt8_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PUInt8(Right)^; end;
-procedure lpeInt8_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PInt8(Right)^; end;
-procedure lpeInt8_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PUInt16(Right)^; end;
-procedure lpeInt8_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PInt16(Right)^; end;
-procedure lpeInt8_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PUInt32(Right)^; end;
-procedure lpeInt8_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PInt32(Right)^; end;
-procedure lpeInt8_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PUInt64(Right)^; end;
-procedure lpeInt8_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PInt64(Right)^; end;
-procedure lpeInt8_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PSingle(Right)^; end;
-procedure lpeInt8_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PDouble(Right)^; end;
-procedure lpeInt8_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PCurrency(Right)^; end;
-procedure lpeInt8_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PExtended(Right)^; end;
-procedure lpeInt8_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <= PVariant(Right)^; end;
-procedure lpeUInt16_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PUInt8(Right)^; end;
-procedure lpeUInt16_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PInt8(Right)^; end;
-procedure lpeUInt16_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PUInt16(Right)^; end;
-procedure lpeUInt16_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PInt16(Right)^; end;
-procedure lpeUInt16_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PUInt32(Right)^; end;
-procedure lpeUInt16_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PInt32(Right)^; end;
-procedure lpeUInt16_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PUInt64(Right)^; end;
-procedure lpeUInt16_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PInt64(Right)^; end;
-procedure lpeUInt16_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PSingle(Right)^; end;
-procedure lpeUInt16_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PDouble(Right)^; end;
-procedure lpeUInt16_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PCurrency(Right)^; end;
-procedure lpeUInt16_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PExtended(Right)^; end;
-procedure lpeUInt16_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PVariant(Right)^; end;
-procedure lpeInt16_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PUInt8(Right)^; end;
-procedure lpeInt16_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PInt8(Right)^; end;
-procedure lpeInt16_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PUInt16(Right)^; end;
-procedure lpeInt16_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PInt16(Right)^; end;
-procedure lpeInt16_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PUInt32(Right)^; end;
-procedure lpeInt16_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PInt32(Right)^; end;
-procedure lpeInt16_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PUInt64(Right)^; end;
-procedure lpeInt16_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PInt64(Right)^; end;
-procedure lpeInt16_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PSingle(Right)^; end;
-procedure lpeInt16_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PDouble(Right)^; end;
-procedure lpeInt16_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PCurrency(Right)^; end;
-procedure lpeInt16_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PExtended(Right)^; end;
-procedure lpeInt16_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <= PVariant(Right)^; end;
-procedure lpeUInt32_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PUInt8(Right)^; end;
-procedure lpeUInt32_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PInt8(Right)^; end;
-procedure lpeUInt32_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PUInt16(Right)^; end;
-procedure lpeUInt32_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PInt16(Right)^; end;
-procedure lpeUInt32_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PUInt32(Right)^; end;
-procedure lpeUInt32_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PInt32(Right)^; end;
-procedure lpeUInt32_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PUInt64(Right)^; end;
-procedure lpeUInt32_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PInt64(Right)^; end;
-procedure lpeUInt32_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PSingle(Right)^; end;
-procedure lpeUInt32_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PDouble(Right)^; end;
-procedure lpeUInt32_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PCurrency(Right)^; end;
-procedure lpeUInt32_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PExtended(Right)^; end;
-procedure lpeUInt32_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PVariant(Right)^; end;
-procedure lpeInt32_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PUInt8(Right)^; end;
-procedure lpeInt32_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PInt8(Right)^; end;
-procedure lpeInt32_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PUInt16(Right)^; end;
-procedure lpeInt32_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PInt16(Right)^; end;
-procedure lpeInt32_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PUInt32(Right)^; end;
-procedure lpeInt32_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PInt32(Right)^; end;
-procedure lpeInt32_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PUInt64(Right)^; end;
-procedure lpeInt32_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PInt64(Right)^; end;
-procedure lpeInt32_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PSingle(Right)^; end;
-procedure lpeInt32_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PDouble(Right)^; end;
-procedure lpeInt32_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PCurrency(Right)^; end;
-procedure lpeInt32_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PExtended(Right)^; end;
-procedure lpeInt32_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <= PVariant(Right)^; end;
-procedure lpeUInt64_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PUInt8(Right)^; end;
-procedure lpeUInt64_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PInt8(Right)^; end;
-procedure lpeUInt64_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PUInt16(Right)^; end;
-procedure lpeUInt64_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PInt16(Right)^; end;
-procedure lpeUInt64_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PUInt32(Right)^; end;
-procedure lpeUInt64_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PInt32(Right)^; end;
-procedure lpeUInt64_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PUInt64(Right)^; end;
-procedure lpeUInt64_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PInt64(Right)^; end;
-procedure lpeUInt64_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PSingle(Right)^; end;
-procedure lpeUInt64_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PDouble(Right)^; end;
-procedure lpeUInt64_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PCurrency(Right)^; end;
-procedure lpeUInt64_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PExtended(Right)^; end;
-procedure lpeUInt64_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PVariant(Right)^; end;
-procedure lpeInt64_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PUInt8(Right)^; end;
-procedure lpeInt64_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PInt8(Right)^; end;
-procedure lpeInt64_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PUInt16(Right)^; end;
-procedure lpeInt64_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PInt16(Right)^; end;
-procedure lpeInt64_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PUInt32(Right)^; end;
-procedure lpeInt64_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PInt32(Right)^; end;
-procedure lpeInt64_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PUInt64(Right)^; end;
-procedure lpeInt64_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PInt64(Right)^; end;
-procedure lpeInt64_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PSingle(Right)^; end;
-procedure lpeInt64_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PDouble(Right)^; end;
-procedure lpeInt64_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PCurrency(Right)^; end;
-procedure lpeInt64_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PExtended(Right)^; end;
-procedure lpeInt64_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <= PVariant(Right)^; end;
-procedure lpeSingle_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PUInt8(Right)^; end;
-procedure lpeSingle_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PInt8(Right)^; end;
-procedure lpeSingle_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PUInt16(Right)^; end;
-procedure lpeSingle_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PInt16(Right)^; end;
-procedure lpeSingle_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PUInt32(Right)^; end;
-procedure lpeSingle_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PInt32(Right)^; end;
-procedure lpeSingle_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PUInt64(Right)^; end;
-procedure lpeSingle_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PInt64(Right)^; end;
-procedure lpeSingle_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PSingle(Right)^; end;
-procedure lpeSingle_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PDouble(Right)^; end;
-procedure lpeSingle_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PCurrency(Right)^; end;
-procedure lpeSingle_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PExtended(Right)^; end;
-procedure lpeSingle_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <= PVariant(Right)^; end;
-procedure lpeDouble_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PUInt8(Right)^; end;
-procedure lpeDouble_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PInt8(Right)^; end;
-procedure lpeDouble_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PUInt16(Right)^; end;
-procedure lpeDouble_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PInt16(Right)^; end;
-procedure lpeDouble_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PUInt32(Right)^; end;
-procedure lpeDouble_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PInt32(Right)^; end;
-procedure lpeDouble_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PUInt64(Right)^; end;
-procedure lpeDouble_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PInt64(Right)^; end;
-procedure lpeDouble_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PSingle(Right)^; end;
-procedure lpeDouble_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PDouble(Right)^; end;
-procedure lpeDouble_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PCurrency(Right)^; end;
-procedure lpeDouble_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PExtended(Right)^; end;
-procedure lpeDouble_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <= PVariant(Right)^; end;
-procedure lpeCurrency_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PUInt8(Right)^; end;
-procedure lpeCurrency_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PInt8(Right)^; end;
-procedure lpeCurrency_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PUInt16(Right)^; end;
-procedure lpeCurrency_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PInt16(Right)^; end;
-procedure lpeCurrency_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PUInt32(Right)^; end;
-procedure lpeCurrency_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PInt32(Right)^; end;
-procedure lpeCurrency_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PUInt64(Right)^; end;
-procedure lpeCurrency_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PInt64(Right)^; end;
-procedure lpeCurrency_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PSingle(Right)^; end;
-procedure lpeCurrency_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PDouble(Right)^; end;
-procedure lpeCurrency_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PCurrency(Right)^; end;
-procedure lpeCurrency_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PExtended(Right)^; end;
-procedure lpeCurrency_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PVariant(Right)^; end;
-procedure lpeExtended_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PUInt8(Right)^; end;
-procedure lpeExtended_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PInt8(Right)^; end;
-procedure lpeExtended_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PUInt16(Right)^; end;
-procedure lpeExtended_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PInt16(Right)^; end;
-procedure lpeExtended_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PUInt32(Right)^; end;
-procedure lpeExtended_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PInt32(Right)^; end;
-procedure lpeExtended_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PUInt64(Right)^; end;
-procedure lpeExtended_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PInt64(Right)^; end;
-procedure lpeExtended_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PSingle(Right)^; end;
-procedure lpeExtended_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PDouble(Right)^; end;
-procedure lpeExtended_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PCurrency(Right)^; end;
-procedure lpeExtended_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PExtended(Right)^; end;
-procedure lpeExtended_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <= PVariant(Right)^; end;
-procedure lpeVariant_LTEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PUInt8(Right)^; end;
-procedure lpeVariant_LTEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PInt8(Right)^; end;
-procedure lpeVariant_LTEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PUInt16(Right)^; end;
-procedure lpeVariant_LTEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PInt16(Right)^; end;
-procedure lpeVariant_LTEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PUInt32(Right)^; end;
-procedure lpeVariant_LTEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PInt32(Right)^; end;
-procedure lpeVariant_LTEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PUInt64(Right)^; end;
-procedure lpeVariant_LTEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PInt64(Right)^; end;
-procedure lpeVariant_LTEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PSingle(Right)^; end;
-procedure lpeVariant_LTEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PDouble(Right)^; end;
-procedure lpeVariant_LTEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PCurrency(Right)^; end;
-procedure lpeVariant_LTEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PExtended(Right)^; end;
-procedure lpeVariant_LTEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <= PVariant(Right)^; end;
-procedure lpeUInt8_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PUInt8(Right)^; end;
-procedure lpeUInt8_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PInt8(Right)^; end;
-procedure lpeUInt8_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PUInt16(Right)^; end;
-procedure lpeUInt8_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PInt16(Right)^; end;
-procedure lpeUInt8_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PUInt32(Right)^; end;
-procedure lpeUInt8_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PInt32(Right)^; end;
-procedure lpeUInt8_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PUInt64(Right)^; end;
-procedure lpeUInt8_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PInt64(Right)^; end;
-procedure lpeUInt8_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PSingle(Right)^; end;
-procedure lpeUInt8_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PDouble(Right)^; end;
-procedure lpeUInt8_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PCurrency(Right)^; end;
-procedure lpeUInt8_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PExtended(Right)^; end;
-procedure lpeUInt8_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PVariant(Right)^; end;
-procedure lpeInt8_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PUInt8(Right)^; end;
-procedure lpeInt8_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PInt8(Right)^; end;
-procedure lpeInt8_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PUInt16(Right)^; end;
-procedure lpeInt8_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PInt16(Right)^; end;
-procedure lpeInt8_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PUInt32(Right)^; end;
-procedure lpeInt8_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PInt32(Right)^; end;
-procedure lpeInt8_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PUInt64(Right)^; end;
-procedure lpeInt8_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PInt64(Right)^; end;
-procedure lpeInt8_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PSingle(Right)^; end;
-procedure lpeInt8_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PDouble(Right)^; end;
-procedure lpeInt8_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PCurrency(Right)^; end;
-procedure lpeInt8_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PExtended(Right)^; end;
-procedure lpeInt8_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt8(Left)^ <> PVariant(Right)^; end;
-procedure lpeUInt16_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PUInt8(Right)^; end;
-procedure lpeUInt16_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PInt8(Right)^; end;
-procedure lpeUInt16_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PUInt16(Right)^; end;
-procedure lpeUInt16_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PInt16(Right)^; end;
-procedure lpeUInt16_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PUInt32(Right)^; end;
-procedure lpeUInt16_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PInt32(Right)^; end;
-procedure lpeUInt16_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PUInt64(Right)^; end;
-procedure lpeUInt16_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PInt64(Right)^; end;
-procedure lpeUInt16_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PSingle(Right)^; end;
-procedure lpeUInt16_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PDouble(Right)^; end;
-procedure lpeUInt16_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PCurrency(Right)^; end;
-procedure lpeUInt16_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PExtended(Right)^; end;
-procedure lpeUInt16_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PVariant(Right)^; end;
-procedure lpeInt16_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PUInt8(Right)^; end;
-procedure lpeInt16_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PInt8(Right)^; end;
-procedure lpeInt16_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PUInt16(Right)^; end;
-procedure lpeInt16_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PInt16(Right)^; end;
-procedure lpeInt16_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PUInt32(Right)^; end;
-procedure lpeInt16_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PInt32(Right)^; end;
-procedure lpeInt16_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PUInt64(Right)^; end;
-procedure lpeInt16_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PInt64(Right)^; end;
-procedure lpeInt16_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PSingle(Right)^; end;
-procedure lpeInt16_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PDouble(Right)^; end;
-procedure lpeInt16_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PCurrency(Right)^; end;
-procedure lpeInt16_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PExtended(Right)^; end;
-procedure lpeInt16_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt16(Left)^ <> PVariant(Right)^; end;
-procedure lpeUInt32_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PUInt8(Right)^; end;
-procedure lpeUInt32_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PInt8(Right)^; end;
-procedure lpeUInt32_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PUInt16(Right)^; end;
-procedure lpeUInt32_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PInt16(Right)^; end;
-procedure lpeUInt32_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PUInt32(Right)^; end;
-procedure lpeUInt32_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PInt32(Right)^; end;
-procedure lpeUInt32_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PUInt64(Right)^; end;
-procedure lpeUInt32_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PInt64(Right)^; end;
-procedure lpeUInt32_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PSingle(Right)^; end;
-procedure lpeUInt32_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PDouble(Right)^; end;
-procedure lpeUInt32_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PCurrency(Right)^; end;
-procedure lpeUInt32_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PExtended(Right)^; end;
-procedure lpeUInt32_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PVariant(Right)^; end;
-procedure lpeInt32_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PUInt8(Right)^; end;
-procedure lpeInt32_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PInt8(Right)^; end;
-procedure lpeInt32_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PUInt16(Right)^; end;
-procedure lpeInt32_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PInt16(Right)^; end;
-procedure lpeInt32_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PUInt32(Right)^; end;
-procedure lpeInt32_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PInt32(Right)^; end;
-procedure lpeInt32_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PUInt64(Right)^; end;
-procedure lpeInt32_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PInt64(Right)^; end;
-procedure lpeInt32_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PSingle(Right)^; end;
-procedure lpeInt32_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PDouble(Right)^; end;
-procedure lpeInt32_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PCurrency(Right)^; end;
-procedure lpeInt32_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PExtended(Right)^; end;
-procedure lpeInt32_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt32(Left)^ <> PVariant(Right)^; end;
-procedure lpeUInt64_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PUInt8(Right)^; end;
-procedure lpeUInt64_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PInt8(Right)^; end;
-procedure lpeUInt64_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PUInt16(Right)^; end;
-procedure lpeUInt64_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PInt16(Right)^; end;
-procedure lpeUInt64_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PUInt32(Right)^; end;
-procedure lpeUInt64_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PInt32(Right)^; end;
-procedure lpeUInt64_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PUInt64(Right)^; end;
-procedure lpeUInt64_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PInt64(Right)^; end;
-procedure lpeUInt64_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PSingle(Right)^; end;
-procedure lpeUInt64_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PDouble(Right)^; end;
-procedure lpeUInt64_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PCurrency(Right)^; end;
-procedure lpeUInt64_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PExtended(Right)^; end;
-procedure lpeUInt64_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PVariant(Right)^; end;
-procedure lpeInt64_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PUInt8(Right)^; end;
-procedure lpeInt64_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PInt8(Right)^; end;
-procedure lpeInt64_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PUInt16(Right)^; end;
-procedure lpeInt64_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PInt16(Right)^; end;
-procedure lpeInt64_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PUInt32(Right)^; end;
-procedure lpeInt64_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PInt32(Right)^; end;
-procedure lpeInt64_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PUInt64(Right)^; end;
-procedure lpeInt64_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PInt64(Right)^; end;
-procedure lpeInt64_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PSingle(Right)^; end;
-procedure lpeInt64_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PDouble(Right)^; end;
-procedure lpeInt64_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PCurrency(Right)^; end;
-procedure lpeInt64_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PExtended(Right)^; end;
-procedure lpeInt64_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PInt64(Left)^ <> PVariant(Right)^; end;
-procedure lpeSingle_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PUInt8(Right)^; end;
-procedure lpeSingle_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PInt8(Right)^; end;
-procedure lpeSingle_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PUInt16(Right)^; end;
-procedure lpeSingle_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PInt16(Right)^; end;
-procedure lpeSingle_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PUInt32(Right)^; end;
-procedure lpeSingle_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PInt32(Right)^; end;
-procedure lpeSingle_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PUInt64(Right)^; end;
-procedure lpeSingle_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PInt64(Right)^; end;
-procedure lpeSingle_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PSingle(Right)^; end;
-procedure lpeSingle_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PDouble(Right)^; end;
-procedure lpeSingle_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PCurrency(Right)^; end;
-procedure lpeSingle_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PExtended(Right)^; end;
-procedure lpeSingle_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PSingle(Left)^ <> PVariant(Right)^; end;
-procedure lpeDouble_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PUInt8(Right)^; end;
-procedure lpeDouble_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PInt8(Right)^; end;
-procedure lpeDouble_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PUInt16(Right)^; end;
-procedure lpeDouble_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PInt16(Right)^; end;
-procedure lpeDouble_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PUInt32(Right)^; end;
-procedure lpeDouble_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PInt32(Right)^; end;
-procedure lpeDouble_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PUInt64(Right)^; end;
-procedure lpeDouble_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PInt64(Right)^; end;
-procedure lpeDouble_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PSingle(Right)^; end;
-procedure lpeDouble_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PDouble(Right)^; end;
-procedure lpeDouble_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PCurrency(Right)^; end;
-procedure lpeDouble_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PExtended(Right)^; end;
-procedure lpeDouble_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PDouble(Left)^ <> PVariant(Right)^; end;
-procedure lpeCurrency_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PUInt8(Right)^; end;
-procedure lpeCurrency_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PInt8(Right)^; end;
-procedure lpeCurrency_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PUInt16(Right)^; end;
-procedure lpeCurrency_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PInt16(Right)^; end;
-procedure lpeCurrency_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PUInt32(Right)^; end;
-procedure lpeCurrency_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PInt32(Right)^; end;
-procedure lpeCurrency_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PUInt64(Right)^; end;
-procedure lpeCurrency_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PInt64(Right)^; end;
-procedure lpeCurrency_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PSingle(Right)^; end;
-procedure lpeCurrency_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PDouble(Right)^; end;
-procedure lpeCurrency_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PCurrency(Right)^; end;
-procedure lpeCurrency_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PExtended(Right)^; end;
-procedure lpeCurrency_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PVariant(Right)^; end;
-procedure lpeExtended_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PUInt8(Right)^; end;
-procedure lpeExtended_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PInt8(Right)^; end;
-procedure lpeExtended_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PUInt16(Right)^; end;
-procedure lpeExtended_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PInt16(Right)^; end;
-procedure lpeExtended_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PUInt32(Right)^; end;
-procedure lpeExtended_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PInt32(Right)^; end;
-procedure lpeExtended_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PUInt64(Right)^; end;
-procedure lpeExtended_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PInt64(Right)^; end;
-procedure lpeExtended_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PSingle(Right)^; end;
-procedure lpeExtended_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PDouble(Right)^; end;
-procedure lpeExtended_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PCurrency(Right)^; end;
-procedure lpeExtended_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PExtended(Right)^; end;
-procedure lpeExtended_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PExtended(Left)^ <> PVariant(Right)^; end;
-procedure lpeVariant_NEQ_UInt8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PUInt8(Right)^; end;
-procedure lpeVariant_NEQ_Int8(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PInt8(Right)^; end;
-procedure lpeVariant_NEQ_UInt16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PUInt16(Right)^; end;
-procedure lpeVariant_NEQ_Int16(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PInt16(Right)^; end;
-procedure lpeVariant_NEQ_UInt32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PUInt32(Right)^; end;
-procedure lpeVariant_NEQ_Int32(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PInt32(Right)^; end;
-procedure lpeVariant_NEQ_UInt64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PUInt64(Right)^; end;
-procedure lpeVariant_NEQ_Int64(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PInt64(Right)^; end;
-procedure lpeVariant_NEQ_Single(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PSingle(Right)^; end;
-procedure lpeVariant_NEQ_Double(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PDouble(Right)^; end;
-procedure lpeVariant_NEQ_Currency(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PCurrency(Right)^; end;
-procedure lpeVariant_NEQ_Extended(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PExtended(Right)^; end;
-procedure lpeVariant_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PVariant(Left)^ <> PVariant(Right)^; end;
-procedure lpeUInt8_AND_UInt8(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PUInt8(Left)^ and PUInt8(Right)^; end;
-procedure lpeUInt8_AND_Int8(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PUInt8(Left)^ and PInt8(Right)^; end;
-procedure lpeUInt8_AND_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := UInt16(PUInt8(Left)^) and UInt16(PUInt16(Right)^); end;
-procedure lpeUInt8_AND_Int16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := Int16(PUInt8(Left)^) and Int16(PInt16(Right)^); end;
-procedure lpeUInt8_AND_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) and UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_AND_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) and Int32(PInt32(Right)^); end;
-procedure lpeUInt8_AND_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) and UInt64(PUInt64(Right)^); end;
-procedure lpeUInt8_AND_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) and Int64(PInt64(Right)^); end;
-procedure lpeUInt8_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ and PVariant(Right)^; end;
-procedure lpeInt8_AND_UInt8(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PInt8(Left)^ and PUInt8(Right)^; end;
-procedure lpeInt8_AND_Int8(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PInt8(Left)^ and PInt8(Right)^; end;
-procedure lpeInt8_AND_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := UInt16(PInt8(Left)^) and UInt16(PUInt16(Right)^); end;
-procedure lpeInt8_AND_Int16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := Int16(PInt8(Left)^) and Int16(PInt16(Right)^); end;
-procedure lpeInt8_AND_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PInt8(Left)^) and UInt32(PUInt32(Right)^); end;
-procedure lpeInt8_AND_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) and Int32(PInt32(Right)^); end;
-procedure lpeInt8_AND_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) and UInt64(PUInt64(Right)^); end;
-procedure lpeInt8_AND_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) and Int64(PInt64(Right)^); end;
-procedure lpeInt8_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ and PVariant(Right)^; end;
-procedure lpeUInt16_AND_UInt8(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^ and PUInt8(Right)^; end;
-procedure lpeUInt16_AND_Int8(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^ and PInt8(Right)^; end;
-procedure lpeUInt16_AND_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^ and PUInt16(Right)^; end;
-procedure lpeUInt16_AND_Int16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^ and PInt16(Right)^; end;
-procedure lpeUInt16_AND_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) and UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_AND_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) and Int32(PInt32(Right)^); end;
-procedure lpeUInt16_AND_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) and UInt64(PUInt64(Right)^); end;
-procedure lpeUInt16_AND_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) and Int64(PInt64(Right)^); end;
-procedure lpeUInt16_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ and PVariant(Right)^; end;
-procedure lpeInt16_AND_UInt8(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt16(Left)^ and PUInt8(Right)^; end;
-procedure lpeInt16_AND_Int8(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt16(Left)^ and PInt8(Right)^; end;
-procedure lpeInt16_AND_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PInt16(Left)^ and PUInt16(Right)^; end;
-procedure lpeInt16_AND_Int16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt16(Left)^ and PInt16(Right)^; end;
-procedure lpeInt16_AND_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PInt16(Left)^) and UInt32(PUInt32(Right)^); end;
-procedure lpeInt16_AND_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) and Int32(PInt32(Right)^); end;
-procedure lpeInt16_AND_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) and UInt64(PUInt64(Right)^); end;
-procedure lpeInt16_AND_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) and Int64(PInt64(Right)^); end;
-procedure lpeInt16_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ and PVariant(Right)^; end;
-procedure lpeUInt32_AND_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ and PUInt8(Right)^; end;
-procedure lpeUInt32_AND_Int8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ and PInt8(Right)^; end;
-procedure lpeUInt32_AND_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ and PUInt16(Right)^; end;
-procedure lpeUInt32_AND_Int16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ and PInt16(Right)^; end;
-procedure lpeUInt32_AND_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ and PUInt32(Right)^; end;
-procedure lpeUInt32_AND_Int32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ and PInt32(Right)^; end;
-procedure lpeUInt32_AND_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) and UInt64(PUInt64(Right)^); end;
-procedure lpeUInt32_AND_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) and Int64(PInt64(Right)^); end;
-procedure lpeUInt32_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ and PVariant(Right)^; end;
-procedure lpeInt32_AND_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ and PUInt8(Right)^; end;
-procedure lpeInt32_AND_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ and PInt8(Right)^; end;
-procedure lpeInt32_AND_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ and PUInt16(Right)^; end;
-procedure lpeInt32_AND_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ and PInt16(Right)^; end;
-procedure lpeInt32_AND_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PInt32(Left)^ and PUInt32(Right)^; end;
-procedure lpeInt32_AND_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ and PInt32(Right)^; end;
-procedure lpeInt32_AND_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) and UInt64(PUInt64(Right)^); end;
-procedure lpeInt32_AND_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) and Int64(PInt64(Right)^); end;
-procedure lpeInt32_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ and PVariant(Right)^; end;
-procedure lpeUInt64_AND_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ and PUInt8(Right)^; end;
-procedure lpeUInt64_AND_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ and PInt8(Right)^; end;
-procedure lpeUInt64_AND_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ and PUInt16(Right)^; end;
-procedure lpeUInt64_AND_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ and PInt16(Right)^; end;
-procedure lpeUInt64_AND_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ and PUInt32(Right)^; end;
-procedure lpeUInt64_AND_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ and PInt32(Right)^; end;
-procedure lpeUInt64_AND_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ and PUInt64(Right)^; end;
-procedure lpeUInt64_AND_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) and Int64(PInt64(Right)^); end;
-procedure lpeUInt64_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ and PVariant(Right)^; end;
-procedure lpeInt64_AND_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ and PUInt8(Right)^; end;
-procedure lpeInt64_AND_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ and PInt8(Right)^; end;
-procedure lpeInt64_AND_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ and PUInt16(Right)^; end;
-procedure lpeInt64_AND_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ and PInt16(Right)^; end;
-procedure lpeInt64_AND_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ and PUInt32(Right)^; end;
-procedure lpeInt64_AND_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ and PInt32(Right)^; end;
-procedure lpeInt64_AND_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ and PUInt64(Right)^; end;
-procedure lpeInt64_AND_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ and PInt64(Right)^; end;
-procedure lpeInt64_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ and PVariant(Right)^; end;
-procedure lpeVariant_AND_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PUInt8(Right)^; end;
-procedure lpeVariant_AND_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PInt8(Right)^; end;
-procedure lpeVariant_AND_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PUInt16(Right)^; end;
-procedure lpeVariant_AND_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PInt16(Right)^; end;
-procedure lpeVariant_AND_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PUInt32(Right)^; end;
-procedure lpeVariant_AND_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PInt32(Right)^; end;
-procedure lpeVariant_AND_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PUInt64(Right)^; end;
-procedure lpeVariant_AND_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PInt64(Right)^; end;
-procedure lpeVariant_AND_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ and PVariant(Right)^; end;
-procedure lpeUInt8_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PUInt8(Left)^; end;
-procedure lpeUInt8_ASGN_Int8(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PInt8(Left)^; end;
-procedure lpeUInt8_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PUInt16(Left)^; end;
-procedure lpeUInt8_ASGN_Int16(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PInt16(Left)^; end;
-procedure lpeUInt8_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PUInt32(Left)^; end;
-procedure lpeUInt8_ASGN_Int32(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PInt32(Left)^; end;
-procedure lpeUInt8_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PUInt64(Left)^; end;
-procedure lpeUInt8_ASGN_Int64(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PInt64(Left)^; end;
-procedure lpeUInt8_ASGN_Variant(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PVariant(Left)^; end;
-procedure lpeInt8_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PUInt8(Left)^; end;
-procedure lpeInt8_ASGN_Int8(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PInt8(Left)^; end;
-procedure lpeInt8_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PUInt16(Left)^; end;
-procedure lpeInt8_ASGN_Int16(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PInt16(Left)^; end;
-procedure lpeInt8_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PUInt32(Left)^; end;
-procedure lpeInt8_ASGN_Int32(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PInt32(Left)^; end;
-procedure lpeInt8_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PUInt64(Left)^; end;
-procedure lpeInt8_ASGN_Int64(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PInt64(Left)^; end;
-procedure lpeInt8_ASGN_Variant(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PVariant(Left)^; end;
-procedure lpeUInt16_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt8(Left)^; end;
-procedure lpeUInt16_ASGN_Int8(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PInt8(Left)^; end;
-procedure lpeUInt16_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^; end;
-procedure lpeUInt16_ASGN_Int16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PInt16(Left)^; end;
-procedure lpeUInt16_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt32(Left)^; end;
-procedure lpeUInt16_ASGN_Int32(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PInt32(Left)^; end;
-procedure lpeUInt16_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt64(Left)^; end;
-procedure lpeUInt16_ASGN_Int64(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PInt64(Left)^; end;
-procedure lpeUInt16_ASGN_Variant(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PVariant(Left)^; end;
-procedure lpeInt16_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PUInt8(Left)^; end;
-procedure lpeInt16_ASGN_Int8(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt8(Left)^; end;
-procedure lpeInt16_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PUInt16(Left)^; end;
-procedure lpeInt16_ASGN_Int16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt16(Left)^; end;
-procedure lpeInt16_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PUInt32(Left)^; end;
-procedure lpeInt16_ASGN_Int32(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt32(Left)^; end;
-procedure lpeInt16_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PUInt64(Left)^; end;
-procedure lpeInt16_ASGN_Int64(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt64(Left)^; end;
-procedure lpeInt16_ASGN_Variant(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PVariant(Left)^; end;
-procedure lpeUInt32_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt8(Left)^; end;
-procedure lpeUInt32_ASGN_Int8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PInt8(Left)^; end;
-procedure lpeUInt32_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt16(Left)^; end;
-procedure lpeUInt32_ASGN_Int16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PInt16(Left)^; end;
-procedure lpeUInt32_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^; end;
-procedure lpeUInt32_ASGN_Int32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PInt32(Left)^; end;
-procedure lpeUInt32_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt64(Left)^; end;
-procedure lpeUInt32_ASGN_Int64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PInt64(Left)^; end;
-procedure lpeUInt32_ASGN_Variant(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PVariant(Left)^; end;
-procedure lpeInt32_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PUInt8(Left)^; end;
-procedure lpeInt32_ASGN_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt8(Left)^; end;
-procedure lpeInt32_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PUInt16(Left)^; end;
-procedure lpeInt32_ASGN_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt16(Left)^; end;
-procedure lpeInt32_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PUInt32(Left)^; end;
-procedure lpeInt32_ASGN_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^; end;
-procedure lpeInt32_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PUInt64(Left)^; end;
-procedure lpeInt32_ASGN_Int64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt64(Left)^; end;
-procedure lpeInt32_ASGN_Variant(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PVariant(Left)^; end;
-procedure lpeUInt64_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt8(Left)^; end;
-procedure lpeUInt64_ASGN_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PInt8(Left)^; end;
-procedure lpeUInt64_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt16(Left)^; end;
-procedure lpeUInt64_ASGN_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PInt16(Left)^; end;
-procedure lpeUInt64_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt32(Left)^; end;
-procedure lpeUInt64_ASGN_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PInt32(Left)^; end;
-procedure lpeUInt64_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^; end;
-procedure lpeUInt64_ASGN_Int64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PInt64(Left)^; end;
-procedure lpeUInt64_ASGN_Variant(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PVariant(Left)^; end;
-procedure lpeInt64_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PUInt8(Left)^; end;
-procedure lpeInt64_ASGN_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt8(Left)^; end;
-procedure lpeInt64_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PUInt16(Left)^; end;
-procedure lpeInt64_ASGN_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt16(Left)^; end;
-procedure lpeInt64_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PUInt32(Left)^; end;
-procedure lpeInt64_ASGN_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt32(Left)^; end;
-procedure lpeInt64_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PUInt64(Left)^; end;
-procedure lpeInt64_ASGN_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^; end;
-procedure lpeInt64_ASGN_Variant(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PVariant(Left)^; end;
-procedure lpeSingle_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt8(Left)^; end;
-procedure lpeSingle_ASGN_Int8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt8(Left)^; end;
-procedure lpeSingle_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt16(Left)^; end;
-procedure lpeSingle_ASGN_Int16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt16(Left)^; end;
-procedure lpeSingle_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt32(Left)^; end;
-procedure lpeSingle_ASGN_Int32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt32(Left)^; end;
-procedure lpeSingle_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt64(Left)^; end;
-procedure lpeSingle_ASGN_Int64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt64(Left)^; end;
-procedure lpeSingle_ASGN_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^; end;
-procedure lpeSingle_ASGN_Double(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PDouble(Left)^; end;
-procedure lpeSingle_ASGN_Currency(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PCurrency(Left)^; end;
-procedure lpeSingle_ASGN_Extended(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PExtended(Left)^; end;
-procedure lpeSingle_ASGN_Variant(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PVariant(Left)^; end;
-procedure lpeDouble_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt8(Left)^; end;
-procedure lpeDouble_ASGN_Int8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt8(Left)^; end;
-procedure lpeDouble_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt16(Left)^; end;
-procedure lpeDouble_ASGN_Int16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt16(Left)^; end;
-procedure lpeDouble_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt32(Left)^; end;
-procedure lpeDouble_ASGN_Int32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt32(Left)^; end;
-procedure lpeDouble_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt64(Left)^; end;
-procedure lpeDouble_ASGN_Int64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt64(Left)^; end;
-procedure lpeDouble_ASGN_Single(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PSingle(Left)^; end;
-procedure lpeDouble_ASGN_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^; end;
-procedure lpeDouble_ASGN_Currency(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PCurrency(Left)^; end;
-procedure lpeDouble_ASGN_Extended(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PExtended(Left)^; end;
-procedure lpeDouble_ASGN_Variant(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PVariant(Left)^; end;
-procedure lpeCurrency_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt8(Left)^; end;
-procedure lpeCurrency_ASGN_Int8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt8(Left)^; end;
-procedure lpeCurrency_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt16(Left)^; end;
-procedure lpeCurrency_ASGN_Int16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt16(Left)^; end;
-procedure lpeCurrency_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt32(Left)^; end;
-procedure lpeCurrency_ASGN_Int32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt32(Left)^; end;
-procedure lpeCurrency_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt64(Left)^; end;
-procedure lpeCurrency_ASGN_Int64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt64(Left)^; end;
-procedure lpeCurrency_ASGN_Single(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PSingle(Left)^; end;
-procedure lpeCurrency_ASGN_Double(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PDouble(Left)^; end;
-procedure lpeCurrency_ASGN_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^; end;
-procedure lpeCurrency_ASGN_Extended(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PExtended(Left)^; end;
-procedure lpeCurrency_ASGN_Variant(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PVariant(Left)^; end;
-procedure lpeExtended_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^; end;
-procedure lpeExtended_ASGN_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^; end;
-procedure lpeExtended_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^; end;
-procedure lpeExtended_ASGN_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^; end;
-procedure lpeExtended_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^; end;
-procedure lpeExtended_ASGN_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^; end;
-procedure lpeExtended_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^; end;
-procedure lpeExtended_ASGN_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^; end;
-procedure lpeExtended_ASGN_Single(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PSingle(Left)^; end;
-procedure lpeExtended_ASGN_Double(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PDouble(Left)^; end;
-procedure lpeExtended_ASGN_Currency(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PCurrency(Left)^; end;
-procedure lpeExtended_ASGN_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^; end;
-procedure lpeExtended_ASGN_Variant(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PVariant(Left)^; end;
-procedure lpeVariant_ASGN_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^; end;
-procedure lpeVariant_ASGN_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^; end;
-procedure lpeVariant_ASGN_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^; end;
-procedure lpeVariant_ASGN_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^; end;
-procedure lpeVariant_ASGN_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^; end;
-procedure lpeVariant_ASGN_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^; end;
-procedure lpeVariant_ASGN_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^; end;
-procedure lpeVariant_ASGN_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^; end;
-procedure lpeVariant_ASGN_Single(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PSingle(Left)^; end;
-procedure lpeVariant_ASGN_Double(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PDouble(Left)^; end;
-procedure lpeVariant_ASGN_Currency(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PCurrency(Left)^; end;
-procedure lpeVariant_ASGN_Extended(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PExtended(Left)^; end;
-procedure lpeVariant_ASGN_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^; end;
-procedure lpeUInt8_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PUInt8(Right)^); end;
-procedure lpeUInt8_IDIV_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PInt8(Right)^); end;
-procedure lpeUInt8_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PUInt16(Right)^); end;
-procedure lpeUInt8_IDIV_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PInt16(Right)^); end;
-procedure lpeUInt8_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) div UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_IDIV_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PInt32(Right)^); end;
-procedure lpeUInt8_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) div UInt64(PUInt64(Right)^); end;
-procedure lpeUInt8_IDIV_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) div Int64(PInt64(Right)^); end;
-procedure lpeUInt8_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ div PVariant(Right)^; end;
-procedure lpeInt8_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PUInt8(Right)^); end;
-procedure lpeInt8_IDIV_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PInt8(Right)^); end;
-procedure lpeInt8_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PUInt16(Right)^); end;
-procedure lpeInt8_IDIV_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PInt16(Right)^); end;
-procedure lpeInt8_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) div Int64(PUInt32(Right)^); end;
-procedure lpeInt8_IDIV_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PInt32(Right)^); end;
-procedure lpeInt8_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) div Int64(PUInt64(Right)^); end;
-procedure lpeInt8_IDIV_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) div Int64(PInt64(Right)^); end;
-procedure lpeInt8_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ div PVariant(Right)^; end;
-procedure lpeUInt16_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PUInt8(Right)^); end;
-procedure lpeUInt16_IDIV_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PInt8(Right)^); end;
-procedure lpeUInt16_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PUInt16(Right)^); end;
-procedure lpeUInt16_IDIV_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PInt16(Right)^); end;
-procedure lpeUInt16_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) div UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_IDIV_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PInt32(Right)^); end;
-procedure lpeUInt16_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) div UInt64(PUInt64(Right)^); end;
-procedure lpeUInt16_IDIV_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) div Int64(PInt64(Right)^); end;
-procedure lpeUInt16_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ div PVariant(Right)^; end;
-procedure lpeInt16_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PUInt8(Right)^); end;
-procedure lpeInt16_IDIV_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PInt8(Right)^); end;
-procedure lpeInt16_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PUInt16(Right)^); end;
-procedure lpeInt16_IDIV_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PInt16(Right)^); end;
-procedure lpeInt16_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) div Int64(PUInt32(Right)^); end;
-procedure lpeInt16_IDIV_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PInt32(Right)^); end;
-procedure lpeInt16_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) div Int64(PUInt64(Right)^); end;
-procedure lpeInt16_IDIV_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) div Int64(PInt64(Right)^); end;
-procedure lpeInt16_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ div PVariant(Right)^; end;
-procedure lpeUInt32_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ div PUInt8(Right)^; end;
-procedure lpeUInt32_IDIV_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) div Int64(PInt8(Right)^); end;
-procedure lpeUInt32_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ div PUInt16(Right)^; end;
-procedure lpeUInt32_IDIV_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) div Int64(PInt16(Right)^); end;
-procedure lpeUInt32_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ div PUInt32(Right)^; end;
-procedure lpeUInt32_IDIV_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) div Int64(PInt32(Right)^); end;
-procedure lpeUInt32_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) div UInt64(PUInt64(Right)^); end;
-procedure lpeUInt32_IDIV_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) div Int64(PInt64(Right)^); end;
-procedure lpeUInt32_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ div PVariant(Right)^; end;
-procedure lpeInt32_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ div PUInt8(Right)^; end;
-procedure lpeInt32_IDIV_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ div PInt8(Right)^; end;
-procedure lpeInt32_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ div PUInt16(Right)^; end;
-procedure lpeInt32_IDIV_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ div PInt16(Right)^; end;
-procedure lpeInt32_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) div Int64(PUInt32(Right)^); end;
-procedure lpeInt32_IDIV_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ div PInt32(Right)^; end;
-procedure lpeInt32_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) div Int64(PUInt64(Right)^); end;
-procedure lpeInt32_IDIV_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) div Int64(PInt64(Right)^); end;
-procedure lpeInt32_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ div PVariant(Right)^; end;
-procedure lpeUInt64_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ div PUInt8(Right)^; end;
-procedure lpeUInt64_IDIV_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) div Int64(PInt8(Right)^); end;
-procedure lpeUInt64_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ div PUInt16(Right)^; end;
-procedure lpeUInt64_IDIV_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) div Int64(PInt16(Right)^); end;
-procedure lpeUInt64_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ div PUInt32(Right)^; end;
-procedure lpeUInt64_IDIV_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) div Int64(PInt32(Right)^); end;
-procedure lpeUInt64_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ div PUInt64(Right)^; end;
-procedure lpeUInt64_IDIV_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) div Int64(PInt64(Right)^); end;
-procedure lpeUInt64_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ div PVariant(Right)^; end;
-procedure lpeInt64_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ div PUInt8(Right)^; end;
-procedure lpeInt64_IDIV_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ div PInt8(Right)^; end;
-procedure lpeInt64_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ div PUInt16(Right)^; end;
-procedure lpeInt64_IDIV_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ div PInt16(Right)^; end;
-procedure lpeInt64_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ div PUInt32(Right)^; end;
-procedure lpeInt64_IDIV_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ div PInt32(Right)^; end;
-procedure lpeInt64_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ div PUInt64(Right)^; end;
-procedure lpeInt64_IDIV_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ div PInt64(Right)^; end;
-procedure lpeInt64_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ div PVariant(Right)^; end;
-procedure lpeVariant_IDIV_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PUInt8(Right)^; end;
-procedure lpeVariant_IDIV_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PInt8(Right)^; end;
-procedure lpeVariant_IDIV_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PUInt16(Right)^; end;
-procedure lpeVariant_IDIV_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PInt16(Right)^; end;
-procedure lpeVariant_IDIV_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PUInt32(Right)^; end;
-procedure lpeVariant_IDIV_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PInt32(Right)^; end;
-procedure lpeVariant_IDIV_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PUInt64(Right)^; end;
-procedure lpeVariant_IDIV_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PInt64(Right)^; end;
-procedure lpeVariant_IDIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ div PVariant(Right)^; end;
-procedure lpeUInt8_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PUInt8(Right)^; end;
-procedure lpeUInt8_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PInt8(Right)^; end;
-procedure lpeUInt8_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PUInt16(Right)^; end;
-procedure lpeUInt8_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PInt16(Right)^; end;
-procedure lpeUInt8_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PUInt32(Right)^; end;
-procedure lpeUInt8_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PInt32(Right)^; end;
-procedure lpeUInt8_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PUInt64(Right)^; end;
-procedure lpeUInt8_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PInt64(Right)^; end;
-procedure lpeUInt8_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt8(Left)^ / PSingle(Right)^; end;
-procedure lpeUInt8_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt8(Left)^ / PDouble(Right)^; end;
-procedure lpeUInt8_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt8(Left)^ / PCurrency(Right)^; end;
-procedure lpeUInt8_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ / PExtended(Right)^; end;
-procedure lpeUInt8_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ / PVariant(Right)^; end;
-procedure lpeInt8_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PUInt8(Right)^; end;
-procedure lpeInt8_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PInt8(Right)^; end;
-procedure lpeInt8_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PUInt16(Right)^; end;
-procedure lpeInt8_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PInt16(Right)^; end;
-procedure lpeInt8_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PUInt32(Right)^; end;
-procedure lpeInt8_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PInt32(Right)^; end;
-procedure lpeInt8_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PUInt64(Right)^; end;
-procedure lpeInt8_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PInt64(Right)^; end;
-procedure lpeInt8_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt8(Left)^ / PSingle(Right)^; end;
-procedure lpeInt8_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt8(Left)^ / PDouble(Right)^; end;
-procedure lpeInt8_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt8(Left)^ / PCurrency(Right)^; end;
-procedure lpeInt8_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ / PExtended(Right)^; end;
-procedure lpeInt8_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ / PVariant(Right)^; end;
-procedure lpeUInt16_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PUInt8(Right)^; end;
-procedure lpeUInt16_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PInt8(Right)^; end;
-procedure lpeUInt16_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PUInt16(Right)^; end;
-procedure lpeUInt16_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PInt16(Right)^; end;
-procedure lpeUInt16_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PUInt32(Right)^; end;
-procedure lpeUInt16_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PInt32(Right)^; end;
-procedure lpeUInt16_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PUInt64(Right)^; end;
-procedure lpeUInt16_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PInt64(Right)^; end;
-procedure lpeUInt16_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt16(Left)^ / PSingle(Right)^; end;
-procedure lpeUInt16_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt16(Left)^ / PDouble(Right)^; end;
-procedure lpeUInt16_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt16(Left)^ / PCurrency(Right)^; end;
-procedure lpeUInt16_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ / PExtended(Right)^; end;
-procedure lpeUInt16_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ / PVariant(Right)^; end;
-procedure lpeInt16_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PUInt8(Right)^; end;
-procedure lpeInt16_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PInt8(Right)^; end;
-procedure lpeInt16_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PUInt16(Right)^; end;
-procedure lpeInt16_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PInt16(Right)^; end;
-procedure lpeInt16_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PUInt32(Right)^; end;
-procedure lpeInt16_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PInt32(Right)^; end;
-procedure lpeInt16_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PUInt64(Right)^; end;
-procedure lpeInt16_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PInt64(Right)^; end;
-procedure lpeInt16_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt16(Left)^ / PSingle(Right)^; end;
-procedure lpeInt16_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt16(Left)^ / PDouble(Right)^; end;
-procedure lpeInt16_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt16(Left)^ / PCurrency(Right)^; end;
-procedure lpeInt16_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ / PExtended(Right)^; end;
-procedure lpeInt16_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ / PVariant(Right)^; end;
-procedure lpeUInt32_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PUInt8(Right)^; end;
-procedure lpeUInt32_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PInt8(Right)^; end;
-procedure lpeUInt32_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PUInt16(Right)^; end;
-procedure lpeUInt32_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PInt16(Right)^; end;
-procedure lpeUInt32_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PUInt32(Right)^; end;
-procedure lpeUInt32_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PInt32(Right)^; end;
-procedure lpeUInt32_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PUInt64(Right)^; end;
-procedure lpeUInt32_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PInt64(Right)^; end;
-procedure lpeUInt32_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt32(Left)^ / PSingle(Right)^; end;
-procedure lpeUInt32_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt32(Left)^ / PDouble(Right)^; end;
-procedure lpeUInt32_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt32(Left)^ / PCurrency(Right)^; end;
-procedure lpeUInt32_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ / PExtended(Right)^; end;
-procedure lpeUInt32_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ / PVariant(Right)^; end;
-procedure lpeInt32_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PUInt8(Right)^; end;
-procedure lpeInt32_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PInt8(Right)^; end;
-procedure lpeInt32_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PUInt16(Right)^; end;
-procedure lpeInt32_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PInt16(Right)^; end;
-procedure lpeInt32_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PUInt32(Right)^; end;
-procedure lpeInt32_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PInt32(Right)^; end;
-procedure lpeInt32_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PUInt64(Right)^; end;
-procedure lpeInt32_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PInt64(Right)^; end;
-procedure lpeInt32_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt32(Left)^ / PSingle(Right)^; end;
-procedure lpeInt32_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt32(Left)^ / PDouble(Right)^; end;
-procedure lpeInt32_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt32(Left)^ / PCurrency(Right)^; end;
-procedure lpeInt32_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ / PExtended(Right)^; end;
-procedure lpeInt32_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ / PVariant(Right)^; end;
-procedure lpeUInt64_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PUInt8(Right)^; end;
-procedure lpeUInt64_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PInt8(Right)^; end;
-procedure lpeUInt64_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PUInt16(Right)^; end;
-procedure lpeUInt64_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PInt16(Right)^; end;
-procedure lpeUInt64_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PUInt32(Right)^; end;
-procedure lpeUInt64_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PInt32(Right)^; end;
-procedure lpeUInt64_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PUInt64(Right)^; end;
-procedure lpeUInt64_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PInt64(Right)^; end;
-procedure lpeUInt64_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt64(Left)^ / PSingle(Right)^; end;
-procedure lpeUInt64_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt64(Left)^ / PDouble(Right)^; end;
-procedure lpeUInt64_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt64(Left)^ / PCurrency(Right)^; end;
-procedure lpeUInt64_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ / PExtended(Right)^; end;
-procedure lpeUInt64_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ / PVariant(Right)^; end;
-procedure lpeInt64_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PUInt8(Right)^; end;
-procedure lpeInt64_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PInt8(Right)^; end;
-procedure lpeInt64_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PUInt16(Right)^; end;
-procedure lpeInt64_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PInt16(Right)^; end;
-procedure lpeInt64_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PUInt32(Right)^; end;
-procedure lpeInt64_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PInt32(Right)^; end;
-procedure lpeInt64_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PUInt64(Right)^; end;
-procedure lpeInt64_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PInt64(Right)^; end;
-procedure lpeInt64_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt64(Left)^ / PSingle(Right)^; end;
-procedure lpeInt64_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt64(Left)^ / PDouble(Right)^; end;
-procedure lpeInt64_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt64(Left)^ / PCurrency(Right)^; end;
-procedure lpeInt64_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ / PExtended(Right)^; end;
-procedure lpeInt64_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ / PVariant(Right)^; end;
-procedure lpeSingle_DIV_UInt8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PUInt8(Right)^; end;
-procedure lpeSingle_DIV_Int8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PInt8(Right)^; end;
-procedure lpeSingle_DIV_UInt16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PUInt16(Right)^; end;
-procedure lpeSingle_DIV_Int16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PInt16(Right)^; end;
-procedure lpeSingle_DIV_UInt32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PUInt32(Right)^; end;
-procedure lpeSingle_DIV_Int32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PInt32(Right)^; end;
-procedure lpeSingle_DIV_UInt64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PUInt64(Right)^; end;
-procedure lpeSingle_DIV_Int64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PInt64(Right)^; end;
-procedure lpeSingle_DIV_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ / PSingle(Right)^; end;
-procedure lpeSingle_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PSingle(Left)^ / PDouble(Right)^; end;
-procedure lpeSingle_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PSingle(Left)^ / PCurrency(Right)^; end;
-procedure lpeSingle_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PSingle(Left)^ / PExtended(Right)^; end;
-procedure lpeSingle_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PSingle(Left)^ / PVariant(Right)^; end;
-procedure lpeDouble_DIV_UInt8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PUInt8(Right)^; end;
-procedure lpeDouble_DIV_Int8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PInt8(Right)^; end;
-procedure lpeDouble_DIV_UInt16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PUInt16(Right)^; end;
-procedure lpeDouble_DIV_Int16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PInt16(Right)^; end;
-procedure lpeDouble_DIV_UInt32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PUInt32(Right)^; end;
-procedure lpeDouble_DIV_Int32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PInt32(Right)^; end;
-procedure lpeDouble_DIV_UInt64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PUInt64(Right)^; end;
-procedure lpeDouble_DIV_Int64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PInt64(Right)^; end;
-procedure lpeDouble_DIV_Single(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PSingle(Right)^; end;
-procedure lpeDouble_DIV_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ / PDouble(Right)^; end;
-procedure lpeDouble_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PDouble(Left)^ / PCurrency(Right)^; end;
-procedure lpeDouble_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PDouble(Left)^ / PExtended(Right)^; end;
-procedure lpeDouble_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PDouble(Left)^ / PVariant(Right)^; end;
-procedure lpeCurrency_DIV_UInt8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PUInt8(Right)^; end;
-procedure lpeCurrency_DIV_Int8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PInt8(Right)^; end;
-procedure lpeCurrency_DIV_UInt16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PUInt16(Right)^; end;
-procedure lpeCurrency_DIV_Int16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PInt16(Right)^; end;
-procedure lpeCurrency_DIV_UInt32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PUInt32(Right)^; end;
-procedure lpeCurrency_DIV_Int32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PInt32(Right)^; end;
-procedure lpeCurrency_DIV_UInt64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PUInt64(Right)^; end;
-procedure lpeCurrency_DIV_Int64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PInt64(Right)^; end;
-procedure lpeCurrency_DIV_Single(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PSingle(Right)^; end;
-procedure lpeCurrency_DIV_Double(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PDouble(Right)^; end;
-procedure lpeCurrency_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PCurrency(Right)^; end;
-procedure lpeCurrency_DIV_Extended(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ / PExtended(Right)^; end;
-procedure lpeCurrency_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PCurrency(Left)^ / PVariant(Right)^; end;
-procedure lpeExtended_DIV_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PUInt8(Right)^; end;
-procedure lpeExtended_DIV_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PInt8(Right)^; end;
-procedure lpeExtended_DIV_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PUInt16(Right)^; end;
-procedure lpeExtended_DIV_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PInt16(Right)^; end;
-procedure lpeExtended_DIV_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PUInt32(Right)^; end;
-procedure lpeExtended_DIV_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PInt32(Right)^; end;
-procedure lpeExtended_DIV_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PUInt64(Right)^; end;
-procedure lpeExtended_DIV_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PInt64(Right)^; end;
-procedure lpeExtended_DIV_Single(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PSingle(Right)^; end;
-procedure lpeExtended_DIV_Double(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PDouble(Right)^; end;
-procedure lpeExtended_DIV_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PExtended(Left)^ / PCurrency(Right)^; end;
-procedure lpeExtended_DIV_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ / PExtended(Right)^; end;
-procedure lpeExtended_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PExtended(Left)^ / PVariant(Right)^; end;
-procedure lpeVariant_DIV_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PUInt8(Right)^; end;
-procedure lpeVariant_DIV_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PInt8(Right)^; end;
-procedure lpeVariant_DIV_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PUInt16(Right)^; end;
-procedure lpeVariant_DIV_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PInt16(Right)^; end;
-procedure lpeVariant_DIV_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PUInt32(Right)^; end;
-procedure lpeVariant_DIV_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PInt32(Right)^; end;
-procedure lpeVariant_DIV_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PUInt64(Right)^; end;
-procedure lpeVariant_DIV_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PInt64(Right)^; end;
-procedure lpeVariant_DIV_Single(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PSingle(Right)^; end;
-procedure lpeVariant_DIV_Double(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PDouble(Right)^; end;
-procedure lpeVariant_DIV_Currency(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PCurrency(Right)^; end;
-procedure lpeVariant_DIV_Extended(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PExtended(Right)^; end;
-procedure lpeVariant_DIV_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ / PVariant(Right)^; end;
-procedure lpeUInt8_SUB_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PUInt8(Right)^); end;
-procedure lpeUInt8_SUB_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PInt8(Right)^); end;
-procedure lpeUInt8_SUB_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PUInt16(Right)^); end;
-procedure lpeUInt8_SUB_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PInt16(Right)^); end;
-procedure lpeUInt8_SUB_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) - Int64(PUInt32(Right)^); end;
-procedure lpeUInt8_SUB_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PInt32(Right)^); end;
-procedure lpeUInt8_SUB_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) - UInt64(PUInt64(Right)^); end;
-procedure lpeUInt8_SUB_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) - Int64(PInt64(Right)^); end;
-procedure lpeUInt8_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt8(Left)^ - PSingle(Right)^; end;
-procedure lpeUInt8_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt8(Left)^ - PDouble(Right)^; end;
-procedure lpeUInt8_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt8(Left)^ - PCurrency(Right)^; end;
-procedure lpeUInt8_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ - PExtended(Right)^; end;
-procedure lpeUInt8_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ - PVariant(Right)^; end;
-procedure lpeInt8_SUB_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PUInt8(Right)^); end;
-procedure lpeInt8_SUB_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PInt8(Right)^); end;
-procedure lpeInt8_SUB_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PUInt16(Right)^); end;
-procedure lpeInt8_SUB_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PInt16(Right)^); end;
-procedure lpeInt8_SUB_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) - Int64(PUInt32(Right)^); end;
-procedure lpeInt8_SUB_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PInt32(Right)^); end;
-procedure lpeInt8_SUB_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) - UInt64(PUInt64(Right)^); end;
-procedure lpeInt8_SUB_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) - Int64(PInt64(Right)^); end;
-procedure lpeInt8_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt8(Left)^ - PSingle(Right)^; end;
-procedure lpeInt8_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt8(Left)^ - PDouble(Right)^; end;
-procedure lpeInt8_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt8(Left)^ - PCurrency(Right)^; end;
-procedure lpeInt8_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ - PExtended(Right)^; end;
-procedure lpeInt8_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ - PVariant(Right)^; end;
-procedure lpeUInt16_SUB_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PUInt8(Right)^); end;
-procedure lpeUInt16_SUB_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PInt8(Right)^); end;
-procedure lpeUInt16_SUB_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PUInt16(Right)^); end;
-procedure lpeUInt16_SUB_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PInt16(Right)^); end;
-procedure lpeUInt16_SUB_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) - Int64(PUInt32(Right)^); end;
-procedure lpeUInt16_SUB_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PInt32(Right)^); end;
-procedure lpeUInt16_SUB_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) - UInt64(PUInt64(Right)^); end;
-procedure lpeUInt16_SUB_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) - Int64(PInt64(Right)^); end;
-procedure lpeUInt16_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt16(Left)^ - PSingle(Right)^; end;
-procedure lpeUInt16_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt16(Left)^ - PDouble(Right)^; end;
-procedure lpeUInt16_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt16(Left)^ - PCurrency(Right)^; end;
-procedure lpeUInt16_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ - PExtended(Right)^; end;
-procedure lpeUInt16_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ - PVariant(Right)^; end;
-procedure lpeInt16_SUB_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PUInt8(Right)^); end;
-procedure lpeInt16_SUB_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PInt8(Right)^); end;
-procedure lpeInt16_SUB_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PUInt16(Right)^); end;
-procedure lpeInt16_SUB_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PInt16(Right)^); end;
-procedure lpeInt16_SUB_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) - Int64(PUInt32(Right)^); end;
-procedure lpeInt16_SUB_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PInt32(Right)^); end;
-procedure lpeInt16_SUB_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) - UInt64(PUInt64(Right)^); end;
-procedure lpeInt16_SUB_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) - Int64(PInt64(Right)^); end;
-procedure lpeInt16_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt16(Left)^ - PSingle(Right)^; end;
-procedure lpeInt16_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt16(Left)^ - PDouble(Right)^; end;
-procedure lpeInt16_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt16(Left)^ - PCurrency(Right)^; end;
-procedure lpeInt16_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ - PExtended(Right)^; end;
-procedure lpeInt16_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ - PVariant(Right)^; end;
-procedure lpeUInt32_SUB_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PUInt8(Right)^); end;
-procedure lpeUInt32_SUB_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PInt8(Right)^); end;
-procedure lpeUInt32_SUB_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PUInt16(Right)^); end;
-procedure lpeUInt32_SUB_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PInt16(Right)^); end;
-procedure lpeUInt32_SUB_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PUInt32(Right)^); end;
-procedure lpeUInt32_SUB_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PInt32(Right)^); end;
-procedure lpeUInt32_SUB_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) - UInt64(PUInt64(Right)^); end;
-procedure lpeUInt32_SUB_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PInt64(Right)^); end;
-procedure lpeUInt32_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt32(Left)^ - PSingle(Right)^; end;
-procedure lpeUInt32_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt32(Left)^ - PDouble(Right)^; end;
-procedure lpeUInt32_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt32(Left)^ - PCurrency(Right)^; end;
-procedure lpeUInt32_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ - PExtended(Right)^; end;
-procedure lpeUInt32_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ - PVariant(Right)^; end;
-procedure lpeInt32_SUB_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ - PUInt8(Right)^; end;
-procedure lpeInt32_SUB_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ - PInt8(Right)^; end;
-procedure lpeInt32_SUB_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ - PUInt16(Right)^; end;
-procedure lpeInt32_SUB_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ - PInt16(Right)^; end;
-procedure lpeInt32_SUB_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) - Int64(PUInt32(Right)^); end;
-procedure lpeInt32_SUB_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ - PInt32(Right)^; end;
-procedure lpeInt32_SUB_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) - UInt64(PUInt64(Right)^); end;
-procedure lpeInt32_SUB_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) - Int64(PInt64(Right)^); end;
-procedure lpeInt32_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt32(Left)^ - PSingle(Right)^; end;
-procedure lpeInt32_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt32(Left)^ - PDouble(Right)^; end;
-procedure lpeInt32_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt32(Left)^ - PCurrency(Right)^; end;
-procedure lpeInt32_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ - PExtended(Right)^; end;
-procedure lpeInt32_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ - PVariant(Right)^; end;
-procedure lpeUInt64_SUB_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ - PUInt8(Right)^; end;
-procedure lpeUInt64_SUB_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ - PInt8(Right)^; end;
-procedure lpeUInt64_SUB_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ - PUInt16(Right)^; end;
-procedure lpeUInt64_SUB_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ - PInt16(Right)^; end;
-procedure lpeUInt64_SUB_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ - PUInt32(Right)^; end;
-procedure lpeUInt64_SUB_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ - PInt32(Right)^; end;
-procedure lpeUInt64_SUB_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ - PUInt64(Right)^; end;
-procedure lpeUInt64_SUB_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) - Int64(PInt64(Right)^); end;
-procedure lpeUInt64_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt64(Left)^ - PSingle(Right)^; end;
-procedure lpeUInt64_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt64(Left)^ - PDouble(Right)^; end;
-procedure lpeUInt64_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt64(Left)^ - PCurrency(Right)^; end;
-procedure lpeUInt64_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ - PExtended(Right)^; end;
-procedure lpeUInt64_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ - PVariant(Right)^; end;
-procedure lpeInt64_SUB_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ - PUInt8(Right)^; end;
-procedure lpeInt64_SUB_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ - PInt8(Right)^; end;
-procedure lpeInt64_SUB_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ - PUInt16(Right)^; end;
-procedure lpeInt64_SUB_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ - PInt16(Right)^; end;
-procedure lpeInt64_SUB_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ - PUInt32(Right)^; end;
-procedure lpeInt64_SUB_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ - PInt32(Right)^; end;
-procedure lpeInt64_SUB_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ - PUInt64(Right)^; end;
-procedure lpeInt64_SUB_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ - PInt64(Right)^; end;
-procedure lpeInt64_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt64(Left)^ - PSingle(Right)^; end;
-procedure lpeInt64_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt64(Left)^ - PDouble(Right)^; end;
-procedure lpeInt64_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt64(Left)^ - PCurrency(Right)^; end;
-procedure lpeInt64_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ - PExtended(Right)^; end;
-procedure lpeInt64_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ - PVariant(Right)^; end;
-procedure lpeSingle_SUB_UInt8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PUInt8(Right)^; end;
-procedure lpeSingle_SUB_Int8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PInt8(Right)^; end;
-procedure lpeSingle_SUB_UInt16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PUInt16(Right)^; end;
-procedure lpeSingle_SUB_Int16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PInt16(Right)^; end;
-procedure lpeSingle_SUB_UInt32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PUInt32(Right)^; end;
-procedure lpeSingle_SUB_Int32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PInt32(Right)^; end;
-procedure lpeSingle_SUB_UInt64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PUInt64(Right)^; end;
-procedure lpeSingle_SUB_Int64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PInt64(Right)^; end;
-procedure lpeSingle_SUB_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ - PSingle(Right)^; end;
-procedure lpeSingle_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PSingle(Left)^ - PDouble(Right)^; end;
-procedure lpeSingle_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PSingle(Left)^ - PCurrency(Right)^; end;
-procedure lpeSingle_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PSingle(Left)^ - PExtended(Right)^; end;
-procedure lpeSingle_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PSingle(Left)^ - PVariant(Right)^; end;
-procedure lpeDouble_SUB_UInt8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PUInt8(Right)^; end;
-procedure lpeDouble_SUB_Int8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PInt8(Right)^; end;
-procedure lpeDouble_SUB_UInt16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PUInt16(Right)^; end;
-procedure lpeDouble_SUB_Int16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PInt16(Right)^; end;
-procedure lpeDouble_SUB_UInt32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PUInt32(Right)^; end;
-procedure lpeDouble_SUB_Int32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PInt32(Right)^; end;
-procedure lpeDouble_SUB_UInt64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PUInt64(Right)^; end;
-procedure lpeDouble_SUB_Int64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PInt64(Right)^; end;
-procedure lpeDouble_SUB_Single(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PSingle(Right)^; end;
-procedure lpeDouble_SUB_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ - PDouble(Right)^; end;
-procedure lpeDouble_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PDouble(Left)^ - PCurrency(Right)^; end;
-procedure lpeDouble_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PDouble(Left)^ - PExtended(Right)^; end;
-procedure lpeDouble_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PDouble(Left)^ - PVariant(Right)^; end;
-procedure lpeCurrency_SUB_UInt8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PUInt8(Right)^; end;
-procedure lpeCurrency_SUB_Int8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PInt8(Right)^; end;
-procedure lpeCurrency_SUB_UInt16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PUInt16(Right)^; end;
-procedure lpeCurrency_SUB_Int16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PInt16(Right)^; end;
-procedure lpeCurrency_SUB_UInt32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PUInt32(Right)^; end;
-procedure lpeCurrency_SUB_Int32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PInt32(Right)^; end;
-procedure lpeCurrency_SUB_UInt64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PUInt64(Right)^; end;
-procedure lpeCurrency_SUB_Int64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PInt64(Right)^; end;
-procedure lpeCurrency_SUB_Single(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PSingle(Right)^; end;
-procedure lpeCurrency_SUB_Double(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PDouble(Right)^; end;
-procedure lpeCurrency_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PCurrency(Right)^; end;
-procedure lpeCurrency_SUB_Extended(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ - PExtended(Right)^; end;
-procedure lpeCurrency_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PCurrency(Left)^ - PVariant(Right)^; end;
-procedure lpeExtended_SUB_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PUInt8(Right)^; end;
-procedure lpeExtended_SUB_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PInt8(Right)^; end;
-procedure lpeExtended_SUB_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PUInt16(Right)^; end;
-procedure lpeExtended_SUB_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PInt16(Right)^; end;
-procedure lpeExtended_SUB_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PUInt32(Right)^; end;
-procedure lpeExtended_SUB_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PInt32(Right)^; end;
-procedure lpeExtended_SUB_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PUInt64(Right)^; end;
-procedure lpeExtended_SUB_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PInt64(Right)^; end;
-procedure lpeExtended_SUB_Single(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PSingle(Right)^; end;
-procedure lpeExtended_SUB_Double(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PDouble(Right)^; end;
-procedure lpeExtended_SUB_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PExtended(Left)^ - PCurrency(Right)^; end;
-procedure lpeExtended_SUB_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ - PExtended(Right)^; end;
-procedure lpeExtended_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PExtended(Left)^ - PVariant(Right)^; end;
-procedure lpeVariant_SUB_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PUInt8(Right)^; end;
-procedure lpeVariant_SUB_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PInt8(Right)^; end;
-procedure lpeVariant_SUB_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PUInt16(Right)^; end;
-procedure lpeVariant_SUB_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PInt16(Right)^; end;
-procedure lpeVariant_SUB_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PUInt32(Right)^; end;
-procedure lpeVariant_SUB_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PInt32(Right)^; end;
-procedure lpeVariant_SUB_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PUInt64(Right)^; end;
-procedure lpeVariant_SUB_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PInt64(Right)^; end;
-procedure lpeVariant_SUB_Single(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PSingle(Right)^; end;
-procedure lpeVariant_SUB_Double(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PDouble(Right)^; end;
-procedure lpeVariant_SUB_Currency(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PCurrency(Right)^; end;
-procedure lpeVariant_SUB_Extended(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PExtended(Right)^; end;
-procedure lpeVariant_SUB_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ - PVariant(Right)^; end;
-procedure lpeUInt8_MOD_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PUInt8(Right)^); end;
-procedure lpeUInt8_MOD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PInt8(Right)^); end;
-procedure lpeUInt8_MOD_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PUInt16(Right)^); end;
-procedure lpeUInt8_MOD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PInt16(Right)^); end;
-procedure lpeUInt8_MOD_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) mod UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_MOD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PInt32(Right)^); end;
-procedure lpeUInt8_MOD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) mod UInt64(PUInt64(Right)^); end;
-procedure lpeUInt8_MOD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) mod Int64(PInt64(Right)^); end;
-procedure lpeUInt8_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ mod PVariant(Right)^; end;
-procedure lpeInt8_MOD_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PUInt8(Right)^); end;
-procedure lpeInt8_MOD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PInt8(Right)^); end;
-procedure lpeInt8_MOD_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PUInt16(Right)^); end;
-procedure lpeInt8_MOD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PInt16(Right)^); end;
-procedure lpeInt8_MOD_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) mod Int64(PUInt32(Right)^); end;
-procedure lpeInt8_MOD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PInt32(Right)^); end;
-procedure lpeInt8_MOD_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) mod Int64(PUInt64(Right)^); end;
-procedure lpeInt8_MOD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) mod Int64(PInt64(Right)^); end;
-procedure lpeInt8_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ mod PVariant(Right)^; end;
-procedure lpeUInt16_MOD_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PUInt8(Right)^); end;
-procedure lpeUInt16_MOD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PInt8(Right)^); end;
-procedure lpeUInt16_MOD_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PUInt16(Right)^); end;
-procedure lpeUInt16_MOD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PInt16(Right)^); end;
-procedure lpeUInt16_MOD_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) mod UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_MOD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PInt32(Right)^); end;
-procedure lpeUInt16_MOD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) mod UInt64(PUInt64(Right)^); end;
-procedure lpeUInt16_MOD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) mod Int64(PInt64(Right)^); end;
-procedure lpeUInt16_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ mod PVariant(Right)^; end;
-procedure lpeInt16_MOD_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PUInt8(Right)^); end;
-procedure lpeInt16_MOD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PInt8(Right)^); end;
-procedure lpeInt16_MOD_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PUInt16(Right)^); end;
-procedure lpeInt16_MOD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PInt16(Right)^); end;
-procedure lpeInt16_MOD_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) mod Int64(PUInt32(Right)^); end;
-procedure lpeInt16_MOD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PInt32(Right)^); end;
-procedure lpeInt16_MOD_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) mod Int64(PUInt64(Right)^); end;
-procedure lpeInt16_MOD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) mod Int64(PInt64(Right)^); end;
-procedure lpeInt16_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ mod PVariant(Right)^; end;
-procedure lpeUInt32_MOD_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ mod PUInt8(Right)^; end;
-procedure lpeUInt32_MOD_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) mod Int64(PInt8(Right)^); end;
-procedure lpeUInt32_MOD_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ mod PUInt16(Right)^; end;
-procedure lpeUInt32_MOD_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) mod Int64(PInt16(Right)^); end;
-procedure lpeUInt32_MOD_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ mod PUInt32(Right)^; end;
-procedure lpeUInt32_MOD_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) mod Int64(PInt32(Right)^); end;
-procedure lpeUInt32_MOD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) mod UInt64(PUInt64(Right)^); end;
-procedure lpeUInt32_MOD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) mod Int64(PInt64(Right)^); end;
-procedure lpeUInt32_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ mod PVariant(Right)^; end;
-procedure lpeInt32_MOD_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ mod PUInt8(Right)^; end;
-procedure lpeInt32_MOD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ mod PInt8(Right)^; end;
-procedure lpeInt32_MOD_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ mod PUInt16(Right)^; end;
-procedure lpeInt32_MOD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ mod PInt16(Right)^; end;
-procedure lpeInt32_MOD_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) mod Int64(PUInt32(Right)^); end;
-procedure lpeInt32_MOD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ mod PInt32(Right)^; end;
-procedure lpeInt32_MOD_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) mod Int64(PUInt64(Right)^); end;
-procedure lpeInt32_MOD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) mod Int64(PInt64(Right)^); end;
-procedure lpeInt32_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ mod PVariant(Right)^; end;
-procedure lpeUInt64_MOD_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ mod PUInt8(Right)^; end;
-procedure lpeUInt64_MOD_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) mod Int64(PInt8(Right)^); end;
-procedure lpeUInt64_MOD_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ mod PUInt16(Right)^; end;
-procedure lpeUInt64_MOD_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) mod Int64(PInt16(Right)^); end;
-procedure lpeUInt64_MOD_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ mod PUInt32(Right)^; end;
-procedure lpeUInt64_MOD_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) mod Int64(PInt32(Right)^); end;
-procedure lpeUInt64_MOD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ mod PUInt64(Right)^; end;
-procedure lpeUInt64_MOD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) mod Int64(PInt64(Right)^); end;
-procedure lpeUInt64_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ mod PVariant(Right)^; end;
-procedure lpeInt64_MOD_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ mod PUInt8(Right)^; end;
-procedure lpeInt64_MOD_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ mod PInt8(Right)^; end;
-procedure lpeInt64_MOD_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ mod PUInt16(Right)^; end;
-procedure lpeInt64_MOD_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ mod PInt16(Right)^; end;
-procedure lpeInt64_MOD_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ mod PUInt32(Right)^; end;
-procedure lpeInt64_MOD_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ mod PInt32(Right)^; end;
-procedure lpeInt64_MOD_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ mod PUInt64(Right)^; end;
-procedure lpeInt64_MOD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ mod PInt64(Right)^; end;
-procedure lpeInt64_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ mod PVariant(Right)^; end;
-procedure lpeVariant_MOD_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PUInt8(Right)^; end;
-procedure lpeVariant_MOD_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PInt8(Right)^; end;
-procedure lpeVariant_MOD_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PUInt16(Right)^; end;
-procedure lpeVariant_MOD_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PInt16(Right)^; end;
-procedure lpeVariant_MOD_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PUInt32(Right)^; end;
-procedure lpeVariant_MOD_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PInt32(Right)^; end;
-procedure lpeVariant_MOD_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PUInt64(Right)^; end;
-procedure lpeVariant_MOD_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PInt64(Right)^; end;
-procedure lpeVariant_MOD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ mod PVariant(Right)^; end;
-procedure lpeUInt8_MUL_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) * UInt32(PUInt8(Right)^); end;
-procedure lpeUInt8_MUL_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) * Int32(PInt8(Right)^); end;
-procedure lpeUInt8_MUL_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) * UInt32(PUInt16(Right)^); end;
-procedure lpeUInt8_MUL_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) * Int32(PInt16(Right)^); end;
-procedure lpeUInt8_MUL_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) * UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_MUL_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) * Int32(PInt32(Right)^); end;
-procedure lpeUInt8_MUL_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) * UInt64(PUInt64(Right)^); end;
-procedure lpeUInt8_MUL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) * Int64(PInt64(Right)^); end;
-procedure lpeUInt8_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt8(Left)^ * PSingle(Right)^; end;
-procedure lpeUInt8_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt8(Left)^ * PDouble(Right)^; end;
-procedure lpeUInt8_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt8(Left)^ * PCurrency(Right)^; end;
-procedure lpeUInt8_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ * PExtended(Right)^; end;
-procedure lpeUInt8_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ * PVariant(Right)^; end;
-procedure lpeInt8_MUL_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PUInt8(Right)^); end;
-procedure lpeInt8_MUL_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PInt8(Right)^); end;
-procedure lpeInt8_MUL_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PUInt16(Right)^); end;
-procedure lpeInt8_MUL_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PInt16(Right)^); end;
-procedure lpeInt8_MUL_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) * Int64(PUInt32(Right)^); end;
-procedure lpeInt8_MUL_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PInt32(Right)^); end;
-procedure lpeInt8_MUL_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) * UInt64(PUInt64(Right)^); end;
-procedure lpeInt8_MUL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) * Int64(PInt64(Right)^); end;
-procedure lpeInt8_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt8(Left)^ * PSingle(Right)^; end;
-procedure lpeInt8_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt8(Left)^ * PDouble(Right)^; end;
-procedure lpeInt8_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt8(Left)^ * PCurrency(Right)^; end;
-procedure lpeInt8_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ * PExtended(Right)^; end;
-procedure lpeInt8_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ * PVariant(Right)^; end;
-procedure lpeUInt16_MUL_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) * UInt32(PUInt8(Right)^); end;
-procedure lpeUInt16_MUL_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) * Int32(PInt8(Right)^); end;
-procedure lpeUInt16_MUL_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) * UInt32(PUInt16(Right)^); end;
-procedure lpeUInt16_MUL_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) * Int32(PInt16(Right)^); end;
-procedure lpeUInt16_MUL_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) * UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_MUL_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) * Int32(PInt32(Right)^); end;
-procedure lpeUInt16_MUL_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) * UInt64(PUInt64(Right)^); end;
-procedure lpeUInt16_MUL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) * Int64(PInt64(Right)^); end;
-procedure lpeUInt16_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt16(Left)^ * PSingle(Right)^; end;
-procedure lpeUInt16_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt16(Left)^ * PDouble(Right)^; end;
-procedure lpeUInt16_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt16(Left)^ * PCurrency(Right)^; end;
-procedure lpeUInt16_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ * PExtended(Right)^; end;
-procedure lpeUInt16_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ * PVariant(Right)^; end;
-procedure lpeInt16_MUL_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PUInt8(Right)^); end;
-procedure lpeInt16_MUL_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PInt8(Right)^); end;
-procedure lpeInt16_MUL_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PUInt16(Right)^); end;
-procedure lpeInt16_MUL_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PInt16(Right)^); end;
-procedure lpeInt16_MUL_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) * Int64(PUInt32(Right)^); end;
-procedure lpeInt16_MUL_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PInt32(Right)^); end;
-procedure lpeInt16_MUL_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) * UInt64(PUInt64(Right)^); end;
-procedure lpeInt16_MUL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) * Int64(PInt64(Right)^); end;
-procedure lpeInt16_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt16(Left)^ * PSingle(Right)^; end;
-procedure lpeInt16_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt16(Left)^ * PDouble(Right)^; end;
-procedure lpeInt16_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt16(Left)^ * PCurrency(Right)^; end;
-procedure lpeInt16_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ * PExtended(Right)^; end;
-procedure lpeInt16_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ * PVariant(Right)^; end;
-procedure lpeUInt32_MUL_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ * PUInt8(Right)^; end;
-procedure lpeUInt32_MUL_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) * Int64(PInt8(Right)^); end;
-procedure lpeUInt32_MUL_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ * PUInt16(Right)^; end;
-procedure lpeUInt32_MUL_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) * Int64(PInt16(Right)^); end;
-procedure lpeUInt32_MUL_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ * PUInt32(Right)^; end;
-procedure lpeUInt32_MUL_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) * Int64(PInt32(Right)^); end;
-procedure lpeUInt32_MUL_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) * UInt64(PUInt64(Right)^); end;
-procedure lpeUInt32_MUL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) * Int64(PInt64(Right)^); end;
-procedure lpeUInt32_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt32(Left)^ * PSingle(Right)^; end;
-procedure lpeUInt32_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt32(Left)^ * PDouble(Right)^; end;
-procedure lpeUInt32_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt32(Left)^ * PCurrency(Right)^; end;
-procedure lpeUInt32_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ * PExtended(Right)^; end;
-procedure lpeUInt32_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ * PVariant(Right)^; end;
-procedure lpeInt32_MUL_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ * PUInt8(Right)^; end;
-procedure lpeInt32_MUL_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ * PInt8(Right)^; end;
-procedure lpeInt32_MUL_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ * PUInt16(Right)^; end;
-procedure lpeInt32_MUL_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ * PInt16(Right)^; end;
-procedure lpeInt32_MUL_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) * Int64(PUInt32(Right)^); end;
-procedure lpeInt32_MUL_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ * PInt32(Right)^; end;
-procedure lpeInt32_MUL_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) * UInt64(PUInt64(Right)^); end;
-procedure lpeInt32_MUL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) * Int64(PInt64(Right)^); end;
-procedure lpeInt32_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt32(Left)^ * PSingle(Right)^; end;
-procedure lpeInt32_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt32(Left)^ * PDouble(Right)^; end;
-procedure lpeInt32_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt32(Left)^ * PCurrency(Right)^; end;
-procedure lpeInt32_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ * PExtended(Right)^; end;
-procedure lpeInt32_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ * PVariant(Right)^; end;
-procedure lpeUInt64_MUL_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ * PUInt8(Right)^; end;
-procedure lpeUInt64_MUL_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ * PInt8(Right)^; end;
-procedure lpeUInt64_MUL_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ * PUInt16(Right)^; end;
-procedure lpeUInt64_MUL_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ * PInt16(Right)^; end;
-procedure lpeUInt64_MUL_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ * PUInt32(Right)^; end;
-procedure lpeUInt64_MUL_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ * PInt32(Right)^; end;
-procedure lpeUInt64_MUL_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ * PUInt64(Right)^; end;
-procedure lpeUInt64_MUL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) * Int64(PInt64(Right)^); end;
-procedure lpeUInt64_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt64(Left)^ * PSingle(Right)^; end;
-procedure lpeUInt64_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt64(Left)^ * PDouble(Right)^; end;
-procedure lpeUInt64_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt64(Left)^ * PCurrency(Right)^; end;
-procedure lpeUInt64_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ * PExtended(Right)^; end;
-procedure lpeUInt64_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ * PVariant(Right)^; end;
-procedure lpeInt64_MUL_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ * PUInt8(Right)^; end;
-procedure lpeInt64_MUL_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ * PInt8(Right)^; end;
-procedure lpeInt64_MUL_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ * PUInt16(Right)^; end;
-procedure lpeInt64_MUL_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ * PInt16(Right)^; end;
-procedure lpeInt64_MUL_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ * PUInt32(Right)^; end;
-procedure lpeInt64_MUL_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ * PInt32(Right)^; end;
-procedure lpeInt64_MUL_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ * PUInt64(Right)^; end;
-procedure lpeInt64_MUL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ * PInt64(Right)^; end;
-procedure lpeInt64_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt64(Left)^ * PSingle(Right)^; end;
-procedure lpeInt64_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt64(Left)^ * PDouble(Right)^; end;
-procedure lpeInt64_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt64(Left)^ * PCurrency(Right)^; end;
-procedure lpeInt64_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ * PExtended(Right)^; end;
-procedure lpeInt64_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ * PVariant(Right)^; end;
-procedure lpeSingle_MUL_UInt8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PUInt8(Right)^; end;
-procedure lpeSingle_MUL_Int8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PInt8(Right)^; end;
-procedure lpeSingle_MUL_UInt16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PUInt16(Right)^; end;
-procedure lpeSingle_MUL_Int16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PInt16(Right)^; end;
-procedure lpeSingle_MUL_UInt32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PUInt32(Right)^; end;
-procedure lpeSingle_MUL_Int32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PInt32(Right)^; end;
-procedure lpeSingle_MUL_UInt64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PUInt64(Right)^; end;
-procedure lpeSingle_MUL_Int64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PInt64(Right)^; end;
-procedure lpeSingle_MUL_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ * PSingle(Right)^; end;
-procedure lpeSingle_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PSingle(Left)^ * PDouble(Right)^; end;
-procedure lpeSingle_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PSingle(Left)^ * PCurrency(Right)^; end;
-procedure lpeSingle_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PSingle(Left)^ * PExtended(Right)^; end;
-procedure lpeSingle_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PSingle(Left)^ * PVariant(Right)^; end;
-procedure lpeDouble_MUL_UInt8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PUInt8(Right)^; end;
-procedure lpeDouble_MUL_Int8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PInt8(Right)^; end;
-procedure lpeDouble_MUL_UInt16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PUInt16(Right)^; end;
-procedure lpeDouble_MUL_Int16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PInt16(Right)^; end;
-procedure lpeDouble_MUL_UInt32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PUInt32(Right)^; end;
-procedure lpeDouble_MUL_Int32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PInt32(Right)^; end;
-procedure lpeDouble_MUL_UInt64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PUInt64(Right)^; end;
-procedure lpeDouble_MUL_Int64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PInt64(Right)^; end;
-procedure lpeDouble_MUL_Single(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PSingle(Right)^; end;
-procedure lpeDouble_MUL_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ * PDouble(Right)^; end;
-procedure lpeDouble_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PDouble(Left)^ * PCurrency(Right)^; end;
-procedure lpeDouble_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PDouble(Left)^ * PExtended(Right)^; end;
-procedure lpeDouble_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PDouble(Left)^ * PVariant(Right)^; end;
-procedure lpeCurrency_MUL_UInt8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PUInt8(Right)^; end;
-procedure lpeCurrency_MUL_Int8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PInt8(Right)^; end;
-procedure lpeCurrency_MUL_UInt16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PUInt16(Right)^; end;
-procedure lpeCurrency_MUL_Int16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PInt16(Right)^; end;
-procedure lpeCurrency_MUL_UInt32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PUInt32(Right)^; end;
-procedure lpeCurrency_MUL_Int32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PInt32(Right)^; end;
-procedure lpeCurrency_MUL_UInt64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PUInt64(Right)^; end;
-procedure lpeCurrency_MUL_Int64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PInt64(Right)^; end;
-procedure lpeCurrency_MUL_Single(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PSingle(Right)^; end;
-procedure lpeCurrency_MUL_Double(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PDouble(Right)^; end;
-procedure lpeCurrency_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PCurrency(Right)^; end;
-procedure lpeCurrency_MUL_Extended(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ * PExtended(Right)^; end;
-procedure lpeCurrency_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PCurrency(Left)^ * PVariant(Right)^; end;
-procedure lpeExtended_MUL_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PUInt8(Right)^; end;
-procedure lpeExtended_MUL_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PInt8(Right)^; end;
-procedure lpeExtended_MUL_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PUInt16(Right)^; end;
-procedure lpeExtended_MUL_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PInt16(Right)^; end;
-procedure lpeExtended_MUL_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PUInt32(Right)^; end;
-procedure lpeExtended_MUL_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PInt32(Right)^; end;
-procedure lpeExtended_MUL_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PUInt64(Right)^; end;
-procedure lpeExtended_MUL_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PInt64(Right)^; end;
-procedure lpeExtended_MUL_Single(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PSingle(Right)^; end;
-procedure lpeExtended_MUL_Double(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PDouble(Right)^; end;
-procedure lpeExtended_MUL_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PExtended(Left)^ * PCurrency(Right)^; end;
-procedure lpeExtended_MUL_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ * PExtended(Right)^; end;
-procedure lpeExtended_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PExtended(Left)^ * PVariant(Right)^; end;
-procedure lpeVariant_MUL_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PUInt8(Right)^; end;
-procedure lpeVariant_MUL_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PInt8(Right)^; end;
-procedure lpeVariant_MUL_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PUInt16(Right)^; end;
-procedure lpeVariant_MUL_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PInt16(Right)^; end;
-procedure lpeVariant_MUL_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PUInt32(Right)^; end;
-procedure lpeVariant_MUL_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PInt32(Right)^; end;
-procedure lpeVariant_MUL_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PUInt64(Right)^; end;
-procedure lpeVariant_MUL_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PInt64(Right)^; end;
-procedure lpeVariant_MUL_Single(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PSingle(Right)^; end;
-procedure lpeVariant_MUL_Double(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PDouble(Right)^; end;
-procedure lpeVariant_MUL_Currency(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PCurrency(Right)^; end;
-procedure lpeVariant_MUL_Extended(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PExtended(Right)^; end;
-procedure lpeVariant_MUL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ * PVariant(Right)^; end;
-procedure lpeUInt8_NOT(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := not PUInt8(Left)^; end;
-procedure lpeInt8_NOT(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := not PInt8(Left)^; end;
-procedure lpeUInt16_NOT(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := not PUInt16(Left)^; end;
-procedure lpeInt16_NOT(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := not PInt16(Left)^; end;
-procedure lpeUInt32_NOT(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := not PUInt32(Left)^; end;
-procedure lpeInt32_NOT(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := not PInt32(Left)^; end;
-procedure lpeUInt64_NOT(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := not PUInt64(Left)^; end;
-procedure lpeInt64_NOT(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := not PInt64(Left)^; end;
-procedure lpeVariant_NOT(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := not PVariant(Left)^; end;
-procedure lpeUInt8_OR_UInt8(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PUInt8(Left)^ or PUInt8(Right)^; end;
-procedure lpeUInt8_OR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) or Int32(PInt8(Right)^); end;
-procedure lpeUInt8_OR_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := UInt16(PUInt8(Left)^) or UInt16(PUInt16(Right)^); end;
-procedure lpeUInt8_OR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) or Int32(PInt16(Right)^); end;
-procedure lpeUInt8_OR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) or UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_OR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) or Int32(PInt32(Right)^); end;
-procedure lpeUInt8_OR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) or UInt64(PUInt64(Right)^); end;
-procedure lpeUInt8_OR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) or Int64(PInt64(Right)^); end;
-procedure lpeUInt8_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ or PVariant(Right)^; end;
-procedure lpeInt8_OR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) or Int32(PUInt8(Right)^); end;
-procedure lpeInt8_OR_Int8(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PInt8(Left)^ or PInt8(Right)^; end;
-procedure lpeInt8_OR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) or Int32(PUInt16(Right)^); end;
-procedure lpeInt8_OR_Int16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := Int16(PInt8(Left)^) or Int16(PInt16(Right)^); end;
-procedure lpeInt8_OR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) or Int64(PUInt32(Right)^); end;
-procedure lpeInt8_OR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) or Int32(PInt32(Right)^); end;
-procedure lpeInt8_OR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) or UInt64(PUInt64(Right)^); end;
-procedure lpeInt8_OR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) or Int64(PInt64(Right)^); end;
-procedure lpeInt8_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ or PVariant(Right)^; end;
-procedure lpeUInt16_OR_UInt8(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^ or PUInt8(Right)^; end;
-procedure lpeUInt16_OR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) or Int32(PInt8(Right)^); end;
-procedure lpeUInt16_OR_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^ or PUInt16(Right)^; end;
-procedure lpeUInt16_OR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) or Int32(PInt16(Right)^); end;
-procedure lpeUInt16_OR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) or UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_OR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) or Int32(PInt32(Right)^); end;
-procedure lpeUInt16_OR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) or UInt64(PUInt64(Right)^); end;
-procedure lpeUInt16_OR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) or Int64(PInt64(Right)^); end;
-procedure lpeUInt16_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ or PVariant(Right)^; end;
-procedure lpeInt16_OR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) or Int32(PUInt8(Right)^); end;
-procedure lpeInt16_OR_Int8(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt16(Left)^ or PInt8(Right)^; end;
-procedure lpeInt16_OR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) or Int32(PUInt16(Right)^); end;
-procedure lpeInt16_OR_Int16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt16(Left)^ or PInt16(Right)^; end;
-procedure lpeInt16_OR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) or Int64(PUInt32(Right)^); end;
-procedure lpeInt16_OR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) or Int32(PInt32(Right)^); end;
-procedure lpeInt16_OR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) or UInt64(PUInt64(Right)^); end;
-procedure lpeInt16_OR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) or Int64(PInt64(Right)^); end;
-procedure lpeInt16_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ or PVariant(Right)^; end;
-procedure lpeUInt32_OR_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ or PUInt8(Right)^; end;
-procedure lpeUInt32_OR_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) or Int64(PInt8(Right)^); end;
-procedure lpeUInt32_OR_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ or PUInt16(Right)^; end;
-procedure lpeUInt32_OR_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) or Int64(PInt16(Right)^); end;
-procedure lpeUInt32_OR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ or PUInt32(Right)^; end;
-procedure lpeUInt32_OR_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) or Int64(PInt32(Right)^); end;
-procedure lpeUInt32_OR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) or UInt64(PUInt64(Right)^); end;
-procedure lpeUInt32_OR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) or Int64(PInt64(Right)^); end;
-procedure lpeUInt32_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ or PVariant(Right)^; end;
-procedure lpeInt32_OR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ or PUInt8(Right)^; end;
-procedure lpeInt32_OR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ or PInt8(Right)^; end;
-procedure lpeInt32_OR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ or PUInt16(Right)^; end;
-procedure lpeInt32_OR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ or PInt16(Right)^; end;
-procedure lpeInt32_OR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) or Int64(PUInt32(Right)^); end;
-procedure lpeInt32_OR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ or PInt32(Right)^; end;
-procedure lpeInt32_OR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) or UInt64(PUInt64(Right)^); end;
-procedure lpeInt32_OR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) or Int64(PInt64(Right)^); end;
-procedure lpeInt32_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ or PVariant(Right)^; end;
-procedure lpeUInt64_OR_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ or PUInt8(Right)^; end;
-procedure lpeUInt64_OR_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ or PInt8(Right)^; end;
-procedure lpeUInt64_OR_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ or PUInt16(Right)^; end;
-procedure lpeUInt64_OR_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ or PInt16(Right)^; end;
-procedure lpeUInt64_OR_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ or PUInt32(Right)^; end;
-procedure lpeUInt64_OR_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ or PInt32(Right)^; end;
-procedure lpeUInt64_OR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ or PUInt64(Right)^; end;
-procedure lpeUInt64_OR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) or Int64(PInt64(Right)^); end;
-procedure lpeUInt64_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ or PVariant(Right)^; end;
-procedure lpeInt64_OR_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ or PUInt8(Right)^; end;
-procedure lpeInt64_OR_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ or PInt8(Right)^; end;
-procedure lpeInt64_OR_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ or PUInt16(Right)^; end;
-procedure lpeInt64_OR_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ or PInt16(Right)^; end;
-procedure lpeInt64_OR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ or PUInt32(Right)^; end;
-procedure lpeInt64_OR_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ or PInt32(Right)^; end;
-procedure lpeInt64_OR_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ or PUInt64(Right)^; end;
-procedure lpeInt64_OR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ or PInt64(Right)^; end;
-procedure lpeInt64_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ or PVariant(Right)^; end;
-procedure lpeVariant_OR_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PUInt8(Right)^; end;
-procedure lpeVariant_OR_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PInt8(Right)^; end;
-procedure lpeVariant_OR_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PUInt16(Right)^; end;
-procedure lpeVariant_OR_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PInt16(Right)^; end;
-procedure lpeVariant_OR_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PUInt32(Right)^; end;
-procedure lpeVariant_OR_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PInt32(Right)^; end;
-procedure lpeVariant_OR_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PUInt64(Right)^; end;
-procedure lpeVariant_OR_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PInt64(Right)^; end;
-procedure lpeVariant_OR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ or PVariant(Right)^; end;
-procedure lpeUInt8_ADD_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) + UInt32(PUInt8(Right)^); end;
-procedure lpeUInt8_ADD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) + Int32(PInt8(Right)^); end;
-procedure lpeUInt8_ADD_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) + UInt32(PUInt16(Right)^); end;
-procedure lpeUInt8_ADD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) + Int32(PInt16(Right)^); end;
-procedure lpeUInt8_ADD_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) + UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_ADD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) + Int32(PInt32(Right)^); end;
-procedure lpeUInt8_ADD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) + UInt64(PUInt64(Right)^); end;
-procedure lpeUInt8_ADD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) + Int64(PInt64(Right)^); end;
-procedure lpeUInt8_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt8(Left)^ + PSingle(Right)^; end;
-procedure lpeUInt8_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt8(Left)^ + PDouble(Right)^; end;
-procedure lpeUInt8_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt8(Left)^ + PCurrency(Right)^; end;
-procedure lpeUInt8_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt8(Left)^ + PExtended(Right)^; end;
-procedure lpeUInt8_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ + PVariant(Right)^; end;
-procedure lpeInt8_ADD_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PUInt8(Right)^); end;
-procedure lpeInt8_ADD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PInt8(Right)^); end;
-procedure lpeInt8_ADD_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PUInt16(Right)^); end;
-procedure lpeInt8_ADD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PInt16(Right)^); end;
-procedure lpeInt8_ADD_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) + Int64(PUInt32(Right)^); end;
-procedure lpeInt8_ADD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PInt32(Right)^); end;
-procedure lpeInt8_ADD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) + UInt64(PUInt64(Right)^); end;
-procedure lpeInt8_ADD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) + Int64(PInt64(Right)^); end;
-procedure lpeInt8_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt8(Left)^ + PSingle(Right)^; end;
-procedure lpeInt8_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt8(Left)^ + PDouble(Right)^; end;
-procedure lpeInt8_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt8(Left)^ + PCurrency(Right)^; end;
-procedure lpeInt8_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt8(Left)^ + PExtended(Right)^; end;
-procedure lpeInt8_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ + PVariant(Right)^; end;
-procedure lpeUInt16_ADD_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) + UInt32(PUInt8(Right)^); end;
-procedure lpeUInt16_ADD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) + Int32(PInt8(Right)^); end;
-procedure lpeUInt16_ADD_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) + UInt32(PUInt16(Right)^); end;
-procedure lpeUInt16_ADD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) + Int32(PInt16(Right)^); end;
-procedure lpeUInt16_ADD_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) + UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_ADD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) + Int32(PInt32(Right)^); end;
-procedure lpeUInt16_ADD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) + UInt64(PUInt64(Right)^); end;
-procedure lpeUInt16_ADD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) + Int64(PInt64(Right)^); end;
-procedure lpeUInt16_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt16(Left)^ + PSingle(Right)^; end;
-procedure lpeUInt16_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt16(Left)^ + PDouble(Right)^; end;
-procedure lpeUInt16_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt16(Left)^ + PCurrency(Right)^; end;
-procedure lpeUInt16_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt16(Left)^ + PExtended(Right)^; end;
-procedure lpeUInt16_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ + PVariant(Right)^; end;
-procedure lpeInt16_ADD_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PUInt8(Right)^); end;
-procedure lpeInt16_ADD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PInt8(Right)^); end;
-procedure lpeInt16_ADD_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PUInt16(Right)^); end;
-procedure lpeInt16_ADD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PInt16(Right)^); end;
-procedure lpeInt16_ADD_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) + Int64(PUInt32(Right)^); end;
-procedure lpeInt16_ADD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PInt32(Right)^); end;
-procedure lpeInt16_ADD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) + UInt64(PUInt64(Right)^); end;
-procedure lpeInt16_ADD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) + Int64(PInt64(Right)^); end;
-procedure lpeInt16_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt16(Left)^ + PSingle(Right)^; end;
-procedure lpeInt16_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt16(Left)^ + PDouble(Right)^; end;
-procedure lpeInt16_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt16(Left)^ + PCurrency(Right)^; end;
-procedure lpeInt16_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt16(Left)^ + PExtended(Right)^; end;
-procedure lpeInt16_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ + PVariant(Right)^; end;
-procedure lpeUInt32_ADD_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ + PUInt8(Right)^; end;
-procedure lpeUInt32_ADD_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) + Int64(PInt8(Right)^); end;
-procedure lpeUInt32_ADD_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ + PUInt16(Right)^; end;
-procedure lpeUInt32_ADD_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) + Int64(PInt16(Right)^); end;
-procedure lpeUInt32_ADD_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ + PUInt32(Right)^; end;
-procedure lpeUInt32_ADD_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) + Int64(PInt32(Right)^); end;
-procedure lpeUInt32_ADD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) + UInt64(PUInt64(Right)^); end;
-procedure lpeUInt32_ADD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) + Int64(PInt64(Right)^); end;
-procedure lpeUInt32_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt32(Left)^ + PSingle(Right)^; end;
-procedure lpeUInt32_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt32(Left)^ + PDouble(Right)^; end;
-procedure lpeUInt32_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt32(Left)^ + PCurrency(Right)^; end;
-procedure lpeUInt32_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt32(Left)^ + PExtended(Right)^; end;
-procedure lpeUInt32_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ + PVariant(Right)^; end;
-procedure lpeInt32_ADD_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ + PUInt8(Right)^; end;
-procedure lpeInt32_ADD_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ + PInt8(Right)^; end;
-procedure lpeInt32_ADD_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ + PUInt16(Right)^; end;
-procedure lpeInt32_ADD_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ + PInt16(Right)^; end;
-procedure lpeInt32_ADD_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) + Int64(PUInt32(Right)^); end;
-procedure lpeInt32_ADD_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ + PInt32(Right)^; end;
-procedure lpeInt32_ADD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) + UInt64(PUInt64(Right)^); end;
-procedure lpeInt32_ADD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) + Int64(PInt64(Right)^); end;
-procedure lpeInt32_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt32(Left)^ + PSingle(Right)^; end;
-procedure lpeInt32_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt32(Left)^ + PDouble(Right)^; end;
-procedure lpeInt32_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt32(Left)^ + PCurrency(Right)^; end;
-procedure lpeInt32_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt32(Left)^ + PExtended(Right)^; end;
-procedure lpeInt32_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ + PVariant(Right)^; end;
-procedure lpeUInt64_ADD_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ + PUInt8(Right)^; end;
-procedure lpeUInt64_ADD_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ + PInt8(Right)^; end;
-procedure lpeUInt64_ADD_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ + PUInt16(Right)^; end;
-procedure lpeUInt64_ADD_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ + PInt16(Right)^; end;
-procedure lpeUInt64_ADD_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ + PUInt32(Right)^; end;
-procedure lpeUInt64_ADD_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ + PInt32(Right)^; end;
-procedure lpeUInt64_ADD_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ + PUInt64(Right)^; end;
-procedure lpeUInt64_ADD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) + Int64(PInt64(Right)^); end;
-procedure lpeUInt64_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PUInt64(Left)^ + PSingle(Right)^; end;
-procedure lpeUInt64_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PUInt64(Left)^ + PDouble(Right)^; end;
-procedure lpeUInt64_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PUInt64(Left)^ + PCurrency(Right)^; end;
-procedure lpeUInt64_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PUInt64(Left)^ + PExtended(Right)^; end;
-procedure lpeUInt64_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ + PVariant(Right)^; end;
-procedure lpeInt64_ADD_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ + PUInt8(Right)^; end;
-procedure lpeInt64_ADD_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ + PInt8(Right)^; end;
-procedure lpeInt64_ADD_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ + PUInt16(Right)^; end;
-procedure lpeInt64_ADD_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ + PInt16(Right)^; end;
-procedure lpeInt64_ADD_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ + PUInt32(Right)^; end;
-procedure lpeInt64_ADD_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ + PInt32(Right)^; end;
-procedure lpeInt64_ADD_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ + PUInt64(Right)^; end;
-procedure lpeInt64_ADD_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ + PInt64(Right)^; end;
-procedure lpeInt64_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PInt64(Left)^ + PSingle(Right)^; end;
-procedure lpeInt64_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PInt64(Left)^ + PDouble(Right)^; end;
-procedure lpeInt64_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PInt64(Left)^ + PCurrency(Right)^; end;
-procedure lpeInt64_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PInt64(Left)^ + PExtended(Right)^; end;
-procedure lpeInt64_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ + PVariant(Right)^; end;
-procedure lpeSingle_ADD_UInt8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PUInt8(Right)^; end;
-procedure lpeSingle_ADD_Int8(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PInt8(Right)^; end;
-procedure lpeSingle_ADD_UInt16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PUInt16(Right)^; end;
-procedure lpeSingle_ADD_Int16(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PInt16(Right)^; end;
-procedure lpeSingle_ADD_UInt32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PUInt32(Right)^; end;
-procedure lpeSingle_ADD_Int32(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PInt32(Right)^; end;
-procedure lpeSingle_ADD_UInt64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PUInt64(Right)^; end;
-procedure lpeSingle_ADD_Int64(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PInt64(Right)^; end;
-procedure lpeSingle_ADD_Single(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := PSingle(Left)^ + PSingle(Right)^; end;
-procedure lpeSingle_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PSingle(Left)^ + PDouble(Right)^; end;
-procedure lpeSingle_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PSingle(Left)^ + PCurrency(Right)^; end;
-procedure lpeSingle_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PSingle(Left)^ + PExtended(Right)^; end;
-procedure lpeSingle_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PSingle(Left)^ + PVariant(Right)^; end;
-procedure lpeDouble_ADD_UInt8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PUInt8(Right)^; end;
-procedure lpeDouble_ADD_Int8(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PInt8(Right)^; end;
-procedure lpeDouble_ADD_UInt16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PUInt16(Right)^; end;
-procedure lpeDouble_ADD_Int16(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PInt16(Right)^; end;
-procedure lpeDouble_ADD_UInt32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PUInt32(Right)^; end;
-procedure lpeDouble_ADD_Int32(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PInt32(Right)^; end;
-procedure lpeDouble_ADD_UInt64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PUInt64(Right)^; end;
-procedure lpeDouble_ADD_Int64(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PInt64(Right)^; end;
-procedure lpeDouble_ADD_Single(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PSingle(Right)^; end;
-procedure lpeDouble_ADD_Double(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := PDouble(Left)^ + PDouble(Right)^; end;
-procedure lpeDouble_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PDouble(Left)^ + PCurrency(Right)^; end;
-procedure lpeDouble_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PDouble(Left)^ + PExtended(Right)^; end;
-procedure lpeDouble_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PDouble(Left)^ + PVariant(Right)^; end;
-procedure lpeCurrency_ADD_UInt8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PUInt8(Right)^; end;
-procedure lpeCurrency_ADD_Int8(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PInt8(Right)^; end;
-procedure lpeCurrency_ADD_UInt16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PUInt16(Right)^; end;
-procedure lpeCurrency_ADD_Int16(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PInt16(Right)^; end;
-procedure lpeCurrency_ADD_UInt32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PUInt32(Right)^; end;
-procedure lpeCurrency_ADD_Int32(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PInt32(Right)^; end;
-procedure lpeCurrency_ADD_UInt64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PUInt64(Right)^; end;
-procedure lpeCurrency_ADD_Int64(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PInt64(Right)^; end;
-procedure lpeCurrency_ADD_Single(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PSingle(Right)^; end;
-procedure lpeCurrency_ADD_Double(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PDouble(Right)^; end;
-procedure lpeCurrency_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PCurrency(Right)^; end;
-procedure lpeCurrency_ADD_Extended(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PCurrency(Left)^ + PExtended(Right)^; end;
-procedure lpeCurrency_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PCurrency(Left)^ + PVariant(Right)^; end;
-procedure lpeExtended_ADD_UInt8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PUInt8(Right)^; end;
-procedure lpeExtended_ADD_Int8(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PInt8(Right)^; end;
-procedure lpeExtended_ADD_UInt16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PUInt16(Right)^; end;
-procedure lpeExtended_ADD_Int16(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PInt16(Right)^; end;
-procedure lpeExtended_ADD_UInt32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PUInt32(Right)^; end;
-procedure lpeExtended_ADD_Int32(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PInt32(Right)^; end;
-procedure lpeExtended_ADD_UInt64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PUInt64(Right)^; end;
-procedure lpeExtended_ADD_Int64(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PInt64(Right)^; end;
-procedure lpeExtended_ADD_Single(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PSingle(Right)^; end;
-procedure lpeExtended_ADD_Double(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PDouble(Right)^; end;
-procedure lpeExtended_ADD_Currency(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := PExtended(Left)^ + PCurrency(Right)^; end;
-procedure lpeExtended_ADD_Extended(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := PExtended(Left)^ + PExtended(Right)^; end;
-procedure lpeExtended_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PExtended(Left)^ + PVariant(Right)^; end;
-procedure lpeVariant_ADD_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PUInt8(Right)^; end;
-procedure lpeVariant_ADD_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PInt8(Right)^; end;
-procedure lpeVariant_ADD_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PUInt16(Right)^; end;
-procedure lpeVariant_ADD_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PInt16(Right)^; end;
-procedure lpeVariant_ADD_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PUInt32(Right)^; end;
-procedure lpeVariant_ADD_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PInt32(Right)^; end;
-procedure lpeVariant_ADD_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PUInt64(Right)^; end;
-procedure lpeVariant_ADD_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PInt64(Right)^; end;
-procedure lpeVariant_ADD_Single(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PSingle(Right)^; end;
-procedure lpeVariant_ADD_Double(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PDouble(Right)^; end;
-procedure lpeVariant_ADD_Currency(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PCurrency(Right)^; end;
-procedure lpeVariant_ADD_Extended(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PExtended(Right)^; end;
-procedure lpeVariant_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ + PVariant(Right)^; end;
-procedure lpeUInt8_SHL_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PUInt8(Right)^); end;
-procedure lpeUInt8_SHL_Int8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PInt8(Right)^); end;
-procedure lpeUInt8_SHL_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PUInt16(Right)^); end;
-procedure lpeUInt8_SHL_Int16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PInt16(Right)^); end;
-procedure lpeUInt8_SHL_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_SHL_Int32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PInt32(Right)^); end;
-procedure lpeUInt8_SHL_UInt64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PUInt64(Right)^); end;
-procedure lpeUInt8_SHL_Int64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PInt64(Right)^); end;
-procedure lpeUInt8_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ shl PVariant(Right)^; end;
-procedure lpeInt8_SHL_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PUInt8(Right)^); end;
-procedure lpeInt8_SHL_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PInt8(Right)^); end;
-procedure lpeInt8_SHL_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PUInt16(Right)^); end;
-procedure lpeInt8_SHL_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PInt16(Right)^); end;
-procedure lpeInt8_SHL_UInt32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PUInt32(Right)^); end;
-procedure lpeInt8_SHL_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PInt32(Right)^); end;
-procedure lpeInt8_SHL_UInt64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PUInt64(Right)^); end;
-procedure lpeInt8_SHL_Int64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PInt64(Right)^); end;
-procedure lpeInt8_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ shl PVariant(Right)^; end;
-procedure lpeUInt16_SHL_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PUInt8(Right)^); end;
-procedure lpeUInt16_SHL_Int8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PInt8(Right)^); end;
-procedure lpeUInt16_SHL_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PUInt16(Right)^); end;
-procedure lpeUInt16_SHL_Int16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PInt16(Right)^); end;
-procedure lpeUInt16_SHL_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_SHL_Int32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PInt32(Right)^); end;
-procedure lpeUInt16_SHL_UInt64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PUInt64(Right)^); end;
-procedure lpeUInt16_SHL_Int64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PInt64(Right)^); end;
-procedure lpeUInt16_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ shl PVariant(Right)^; end;
-procedure lpeInt16_SHL_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PUInt8(Right)^); end;
-procedure lpeInt16_SHL_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PInt8(Right)^); end;
-procedure lpeInt16_SHL_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PUInt16(Right)^); end;
-procedure lpeInt16_SHL_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PInt16(Right)^); end;
-procedure lpeInt16_SHL_UInt32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PUInt32(Right)^); end;
-procedure lpeInt16_SHL_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PInt32(Right)^); end;
-procedure lpeInt16_SHL_UInt64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PUInt64(Right)^); end;
-procedure lpeInt16_SHL_Int64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PInt64(Right)^); end;
-procedure lpeInt16_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ shl PVariant(Right)^; end;
-procedure lpeUInt32_SHL_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shl PUInt8(Right)^; end;
-procedure lpeUInt32_SHL_Int8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shl PInt8(Right)^; end;
-procedure lpeUInt32_SHL_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shl PUInt16(Right)^; end;
-procedure lpeUInt32_SHL_Int16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shl PInt16(Right)^; end;
-procedure lpeUInt32_SHL_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shl PUInt32(Right)^; end;
-procedure lpeUInt32_SHL_Int32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shl PInt32(Right)^; end;
-procedure lpeUInt32_SHL_UInt64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shl PUInt64(Right)^; end;
-procedure lpeUInt32_SHL_Int64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shl PInt64(Right)^; end;
-procedure lpeUInt32_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ shl PVariant(Right)^; end;
-procedure lpeInt32_SHL_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shl PUInt8(Right)^; end;
-procedure lpeInt32_SHL_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shl PInt8(Right)^; end;
-procedure lpeInt32_SHL_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shl PUInt16(Right)^; end;
-procedure lpeInt32_SHL_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shl PInt16(Right)^; end;
-procedure lpeInt32_SHL_UInt32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shl PUInt32(Right)^; end;
-procedure lpeInt32_SHL_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shl PInt32(Right)^; end;
-procedure lpeInt32_SHL_UInt64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shl PUInt64(Right)^; end;
-procedure lpeInt32_SHL_Int64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shl PInt64(Right)^; end;
-procedure lpeInt32_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ shl PVariant(Right)^; end;
-procedure lpeUInt64_SHL_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shl PUInt8(Right)^; end;
-procedure lpeUInt64_SHL_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shl PInt8(Right)^; end;
-procedure lpeUInt64_SHL_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shl PUInt16(Right)^; end;
-procedure lpeUInt64_SHL_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shl PInt16(Right)^; end;
-procedure lpeUInt64_SHL_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shl PUInt32(Right)^; end;
-procedure lpeUInt64_SHL_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shl PInt32(Right)^; end;
-procedure lpeUInt64_SHL_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shl PUInt64(Right)^; end;
-procedure lpeUInt64_SHL_Int64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shl PInt64(Right)^; end;
-procedure lpeUInt64_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ shl PVariant(Right)^; end;
-procedure lpeInt64_SHL_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shl PUInt8(Right)^; end;
-procedure lpeInt64_SHL_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shl PInt8(Right)^; end;
-procedure lpeInt64_SHL_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shl PUInt16(Right)^; end;
-procedure lpeInt64_SHL_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shl PInt16(Right)^; end;
-procedure lpeInt64_SHL_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shl PUInt32(Right)^; end;
-procedure lpeInt64_SHL_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shl PInt32(Right)^; end;
-procedure lpeInt64_SHL_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shl PUInt64(Right)^; end;
-procedure lpeInt64_SHL_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shl PInt64(Right)^; end;
-procedure lpeInt64_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ shl PVariant(Right)^; end;
-procedure lpeVariant_SHL_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PUInt8(Right)^; end;
-procedure lpeVariant_SHL_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PInt8(Right)^; end;
-procedure lpeVariant_SHL_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PUInt16(Right)^; end;
-procedure lpeVariant_SHL_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PInt16(Right)^; end;
-procedure lpeVariant_SHL_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PUInt32(Right)^; end;
-procedure lpeVariant_SHL_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PInt32(Right)^; end;
-procedure lpeVariant_SHL_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PUInt64(Right)^; end;
-procedure lpeVariant_SHL_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PInt64(Right)^; end;
-procedure lpeVariant_SHL_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shl PVariant(Right)^; end;
-procedure lpeUInt8_SHR_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PUInt8(Right)^); end;
-procedure lpeUInt8_SHR_Int8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PInt8(Right)^); end;
-procedure lpeUInt8_SHR_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PUInt16(Right)^); end;
-procedure lpeUInt8_SHR_Int16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PInt16(Right)^); end;
-procedure lpeUInt8_SHR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_SHR_Int32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PInt32(Right)^); end;
-procedure lpeUInt8_SHR_UInt64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PUInt64(Right)^); end;
-procedure lpeUInt8_SHR_Int64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PInt64(Right)^); end;
-procedure lpeUInt8_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ shr PVariant(Right)^; end;
-procedure lpeInt8_SHR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PUInt8(Right)^); end;
-procedure lpeInt8_SHR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PInt8(Right)^); end;
-procedure lpeInt8_SHR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PUInt16(Right)^); end;
-procedure lpeInt8_SHR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PInt16(Right)^); end;
-procedure lpeInt8_SHR_UInt32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PUInt32(Right)^); end;
-procedure lpeInt8_SHR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PInt32(Right)^); end;
-procedure lpeInt8_SHR_UInt64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PUInt64(Right)^); end;
-procedure lpeInt8_SHR_Int64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PInt64(Right)^); end;
-procedure lpeInt8_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ shr PVariant(Right)^; end;
-procedure lpeUInt16_SHR_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PUInt8(Right)^); end;
-procedure lpeUInt16_SHR_Int8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PInt8(Right)^); end;
-procedure lpeUInt16_SHR_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PUInt16(Right)^); end;
-procedure lpeUInt16_SHR_Int16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PInt16(Right)^); end;
-procedure lpeUInt16_SHR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_SHR_Int32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PInt32(Right)^); end;
-procedure lpeUInt16_SHR_UInt64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PUInt64(Right)^); end;
-procedure lpeUInt16_SHR_Int64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PInt64(Right)^); end;
-procedure lpeUInt16_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ shr PVariant(Right)^; end;
-procedure lpeInt16_SHR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PUInt8(Right)^); end;
-procedure lpeInt16_SHR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PInt8(Right)^); end;
-procedure lpeInt16_SHR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PUInt16(Right)^); end;
-procedure lpeInt16_SHR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PInt16(Right)^); end;
-procedure lpeInt16_SHR_UInt32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PUInt32(Right)^); end;
-procedure lpeInt16_SHR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PInt32(Right)^); end;
-procedure lpeInt16_SHR_UInt64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PUInt64(Right)^); end;
-procedure lpeInt16_SHR_Int64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PInt64(Right)^); end;
-procedure lpeInt16_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ shr PVariant(Right)^; end;
-procedure lpeUInt32_SHR_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shr PUInt8(Right)^; end;
-procedure lpeUInt32_SHR_Int8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shr PInt8(Right)^; end;
-procedure lpeUInt32_SHR_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shr PUInt16(Right)^; end;
-procedure lpeUInt32_SHR_Int16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shr PInt16(Right)^; end;
-procedure lpeUInt32_SHR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shr PUInt32(Right)^; end;
-procedure lpeUInt32_SHR_Int32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shr PInt32(Right)^; end;
-procedure lpeUInt32_SHR_UInt64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shr PUInt64(Right)^; end;
-procedure lpeUInt32_SHR_Int64(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ shr PInt64(Right)^; end;
-procedure lpeUInt32_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ shr PVariant(Right)^; end;
-procedure lpeInt32_SHR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shr PUInt8(Right)^; end;
-procedure lpeInt32_SHR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shr PInt8(Right)^; end;
-procedure lpeInt32_SHR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shr PUInt16(Right)^; end;
-procedure lpeInt32_SHR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shr PInt16(Right)^; end;
-procedure lpeInt32_SHR_UInt32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shr PUInt32(Right)^; end;
-procedure lpeInt32_SHR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shr PInt32(Right)^; end;
-procedure lpeInt32_SHR_UInt64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shr PUInt64(Right)^; end;
-procedure lpeInt32_SHR_Int64(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ shr PInt64(Right)^; end;
-procedure lpeInt32_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ shr PVariant(Right)^; end;
-procedure lpeUInt64_SHR_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shr PUInt8(Right)^; end;
-procedure lpeUInt64_SHR_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shr PInt8(Right)^; end;
-procedure lpeUInt64_SHR_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shr PUInt16(Right)^; end;
-procedure lpeUInt64_SHR_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shr PInt16(Right)^; end;
-procedure lpeUInt64_SHR_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shr PUInt32(Right)^; end;
-procedure lpeUInt64_SHR_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shr PInt32(Right)^; end;
-procedure lpeUInt64_SHR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shr PUInt64(Right)^; end;
-procedure lpeUInt64_SHR_Int64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ shr PInt64(Right)^; end;
-procedure lpeUInt64_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ shr PVariant(Right)^; end;
-procedure lpeInt64_SHR_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shr PUInt8(Right)^; end;
-procedure lpeInt64_SHR_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shr PInt8(Right)^; end;
-procedure lpeInt64_SHR_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shr PUInt16(Right)^; end;
-procedure lpeInt64_SHR_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shr PInt16(Right)^; end;
-procedure lpeInt64_SHR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shr PUInt32(Right)^; end;
-procedure lpeInt64_SHR_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shr PInt32(Right)^; end;
-procedure lpeInt64_SHR_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shr PUInt64(Right)^; end;
-procedure lpeInt64_SHR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ shr PInt64(Right)^; end;
-procedure lpeInt64_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ shr PVariant(Right)^; end;
-procedure lpeVariant_SHR_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PUInt8(Right)^; end;
-procedure lpeVariant_SHR_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PInt8(Right)^; end;
-procedure lpeVariant_SHR_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PUInt16(Right)^; end;
-procedure lpeVariant_SHR_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PInt16(Right)^; end;
-procedure lpeVariant_SHR_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PUInt32(Right)^; end;
-procedure lpeVariant_SHR_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PInt32(Right)^; end;
-procedure lpeVariant_SHR_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PUInt64(Right)^; end;
-procedure lpeVariant_SHR_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PInt64(Right)^; end;
-procedure lpeVariant_SHR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ shr PVariant(Right)^; end;
-procedure lpeUInt8_XOR_UInt8(const Dest, Left, Right: Pointer); begin PUInt8(Dest)^ := PUInt8(Left)^ xor PUInt8(Right)^; end;
-procedure lpeUInt8_XOR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) xor Int32(PInt8(Right)^); end;
-procedure lpeUInt8_XOR_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := UInt16(PUInt8(Left)^) xor UInt16(PUInt16(Right)^); end;
-procedure lpeUInt8_XOR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) xor Int32(PInt16(Right)^); end;
-procedure lpeUInt8_XOR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) xor UInt32(PUInt32(Right)^); end;
-procedure lpeUInt8_XOR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt8(Left)^) xor Int32(PInt32(Right)^); end;
-procedure lpeUInt8_XOR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) xor UInt64(PUInt64(Right)^); end;
-procedure lpeUInt8_XOR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt8(Left)^) xor Int64(PInt64(Right)^); end;
-procedure lpeUInt8_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt8(Left)^ xor PVariant(Right)^; end;
-procedure lpeInt8_XOR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) xor Int32(PUInt8(Right)^); end;
-procedure lpeInt8_XOR_Int8(const Dest, Left, Right: Pointer); begin PInt8(Dest)^ := PInt8(Left)^ xor PInt8(Right)^; end;
-procedure lpeInt8_XOR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) xor Int32(PUInt16(Right)^); end;
-procedure lpeInt8_XOR_Int16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := Int16(PInt8(Left)^) xor Int16(PInt16(Right)^); end;
-procedure lpeInt8_XOR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) xor Int64(PUInt32(Right)^); end;
-procedure lpeInt8_XOR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt8(Left)^) xor Int32(PInt32(Right)^); end;
-procedure lpeInt8_XOR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) xor UInt64(PUInt64(Right)^); end;
-procedure lpeInt8_XOR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt8(Left)^) xor Int64(PInt64(Right)^); end;
-procedure lpeInt8_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt8(Left)^ xor PVariant(Right)^; end;
-procedure lpeUInt16_XOR_UInt8(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^ xor PUInt8(Right)^; end;
-procedure lpeUInt16_XOR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) xor Int32(PInt8(Right)^); end;
-procedure lpeUInt16_XOR_UInt16(const Dest, Left, Right: Pointer); begin PUInt16(Dest)^ := PUInt16(Left)^ xor PUInt16(Right)^; end;
-procedure lpeUInt16_XOR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) xor Int32(PInt16(Right)^); end;
-procedure lpeUInt16_XOR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) xor UInt32(PUInt32(Right)^); end;
-procedure lpeUInt16_XOR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PUInt16(Left)^) xor Int32(PInt32(Right)^); end;
-procedure lpeUInt16_XOR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) xor UInt64(PUInt64(Right)^); end;
-procedure lpeUInt16_XOR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt16(Left)^) xor Int64(PInt64(Right)^); end;
-procedure lpeUInt16_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt16(Left)^ xor PVariant(Right)^; end;
-procedure lpeInt16_XOR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) xor Int32(PUInt8(Right)^); end;
-procedure lpeInt16_XOR_Int8(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt16(Left)^ xor PInt8(Right)^; end;
-procedure lpeInt16_XOR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) xor Int32(PUInt16(Right)^); end;
-procedure lpeInt16_XOR_Int16(const Dest, Left, Right: Pointer); begin PInt16(Dest)^ := PInt16(Left)^ xor PInt16(Right)^; end;
-procedure lpeInt16_XOR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) xor Int64(PUInt32(Right)^); end;
-procedure lpeInt16_XOR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := Int32(PInt16(Left)^) xor Int32(PInt32(Right)^); end;
-procedure lpeInt16_XOR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) xor UInt64(PUInt64(Right)^); end;
-procedure lpeInt16_XOR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt16(Left)^) xor Int64(PInt64(Right)^); end;
-procedure lpeInt16_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt16(Left)^ xor PVariant(Right)^; end;
-procedure lpeUInt32_XOR_UInt8(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ xor PUInt8(Right)^; end;
-procedure lpeUInt32_XOR_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) xor Int64(PInt8(Right)^); end;
-procedure lpeUInt32_XOR_UInt16(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ xor PUInt16(Right)^; end;
-procedure lpeUInt32_XOR_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) xor Int64(PInt16(Right)^); end;
-procedure lpeUInt32_XOR_UInt32(const Dest, Left, Right: Pointer); begin PUInt32(Dest)^ := PUInt32(Left)^ xor PUInt32(Right)^; end;
-procedure lpeUInt32_XOR_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) xor Int64(PInt32(Right)^); end;
-procedure lpeUInt32_XOR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) xor UInt64(PUInt64(Right)^); end;
-procedure lpeUInt32_XOR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt32(Left)^) xor Int64(PInt64(Right)^); end;
-procedure lpeUInt32_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt32(Left)^ xor PVariant(Right)^; end;
-procedure lpeInt32_XOR_UInt8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ xor PUInt8(Right)^; end;
-procedure lpeInt32_XOR_Int8(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ xor PInt8(Right)^; end;
-procedure lpeInt32_XOR_UInt16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ xor PUInt16(Right)^; end;
-procedure lpeInt32_XOR_Int16(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ xor PInt16(Right)^; end;
-procedure lpeInt32_XOR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) xor Int64(PUInt32(Right)^); end;
-procedure lpeInt32_XOR_Int32(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := PInt32(Left)^ xor PInt32(Right)^; end;
-procedure lpeInt32_XOR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) xor UInt64(PUInt64(Right)^); end;
-procedure lpeInt32_XOR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PInt32(Left)^) xor Int64(PInt64(Right)^); end;
-procedure lpeInt32_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt32(Left)^ xor PVariant(Right)^; end;
-procedure lpeUInt64_XOR_UInt8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ xor PUInt8(Right)^; end;
-procedure lpeUInt64_XOR_Int8(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ xor PInt8(Right)^; end;
-procedure lpeUInt64_XOR_UInt16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ xor PUInt16(Right)^; end;
-procedure lpeUInt64_XOR_Int16(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ xor PInt16(Right)^; end;
-procedure lpeUInt64_XOR_UInt32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ xor PUInt32(Right)^; end;
-procedure lpeUInt64_XOR_Int32(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ xor PInt32(Right)^; end;
-procedure lpeUInt64_XOR_UInt64(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := PUInt64(Left)^ xor PUInt64(Right)^; end;
-procedure lpeUInt64_XOR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := Int64(PUInt64(Left)^) xor Int64(PInt64(Right)^); end;
-procedure lpeUInt64_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUInt64(Left)^ xor PVariant(Right)^; end;
-procedure lpeInt64_XOR_UInt8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ xor PUInt8(Right)^; end;
-procedure lpeInt64_XOR_Int8(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ xor PInt8(Right)^; end;
-procedure lpeInt64_XOR_UInt16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ xor PUInt16(Right)^; end;
-procedure lpeInt64_XOR_Int16(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ xor PInt16(Right)^; end;
-procedure lpeInt64_XOR_UInt32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ xor PUInt32(Right)^; end;
-procedure lpeInt64_XOR_Int32(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ xor PInt32(Right)^; end;
-procedure lpeInt64_XOR_UInt64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ xor PUInt64(Right)^; end;
-procedure lpeInt64_XOR_Int64(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := PInt64(Left)^ xor PInt64(Right)^; end;
-procedure lpeInt64_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PInt64(Left)^ xor PVariant(Right)^; end;
-procedure lpeVariant_XOR_UInt8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PUInt8(Right)^; end;
-procedure lpeVariant_XOR_Int8(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PInt8(Right)^; end;
-procedure lpeVariant_XOR_UInt16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PUInt16(Right)^; end;
-procedure lpeVariant_XOR_Int16(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PInt16(Right)^; end;
-procedure lpeVariant_XOR_UInt32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PUInt32(Right)^; end;
-procedure lpeVariant_XOR_Int32(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PInt32(Right)^; end;
-procedure lpeVariant_XOR_UInt64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PUInt64(Right)^; end;
-procedure lpeVariant_XOR_Int64(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PInt64(Right)^; end;
-procedure lpeVariant_XOR_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PVariant(Left)^ xor PVariant(Right)^; end;
-procedure lpeUInt8_UMIN(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := -PUInt8(Left)^; end;
-procedure lpeInt8_UMIN(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := -PInt8(Left)^; end;
-procedure lpeUInt16_UMIN(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := -PUInt16(Left)^; end;
-procedure lpeInt16_UMIN(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := -PInt16(Left)^; end;
-procedure lpeUInt32_UMIN(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := -PUInt32(Left)^; end;
-procedure lpeInt32_UMIN(const Dest, Left, Right: Pointer); begin PInt32(Dest)^ := -PInt32(Left)^; end;
-procedure lpeUInt64_UMIN(const Dest, Left, Right: Pointer); begin PUInt64(Dest)^ := -PUInt64(Left)^; end;
-procedure lpeInt64_UMIN(const Dest, Left, Right: Pointer); begin PInt64(Dest)^ := -PInt64(Left)^; end;
-procedure lpeSingle_UMIN(const Dest, Left, Right: Pointer); begin PSingle(Dest)^ := -PSingle(Left)^; end;
-procedure lpeDouble_UMIN(const Dest, Left, Right: Pointer); begin PDouble(Dest)^ := -PDouble(Left)^; end;
-procedure lpeCurrency_UMIN(const Dest, Left, Right: Pointer); begin PCurrency(Dest)^ := -PCurrency(Left)^; end;
-procedure lpeExtended_UMIN(const Dest, Left, Right: Pointer); begin PExtended(Dest)^ := -PExtended(Left)^; end;
-procedure lpeVariant_UMIN(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := -PVariant(Left)^; end;
+procedure lpeUInt8_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PUInt8(Right)^; end;
+procedure lpeUInt8_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PInt8(Right)^; end;
+procedure lpeUInt8_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PUInt16(Right)^; end;
+procedure lpeUInt8_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PInt16(Right)^; end;
+procedure lpeUInt8_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PUInt32(Right)^; end;
+procedure lpeUInt8_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PInt32(Right)^; end;
+procedure lpeUInt8_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PUInt64(Right)^; end;
+procedure lpeUInt8_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PInt64(Right)^; end;
+procedure lpeUInt8_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PSingle(Right)^; end;
+procedure lpeUInt8_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PDouble(Right)^; end;
+procedure lpeUInt8_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PCurrency(Right)^; end;
+procedure lpeUInt8_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PExtended(Right)^; end;
+procedure lpeUInt8_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ = PVariant(Right)^; end;
+procedure lpeInt8_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PUInt8(Right)^; end;
+procedure lpeInt8_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PInt8(Right)^; end;
+procedure lpeInt8_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PUInt16(Right)^; end;
+procedure lpeInt8_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PInt16(Right)^; end;
+procedure lpeInt8_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PUInt32(Right)^; end;
+procedure lpeInt8_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PInt32(Right)^; end;
+procedure lpeInt8_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PUInt64(Right)^; end;
+procedure lpeInt8_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PInt64(Right)^; end;
+procedure lpeInt8_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PSingle(Right)^; end;
+procedure lpeInt8_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PDouble(Right)^; end;
+procedure lpeInt8_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PCurrency(Right)^; end;
+procedure lpeInt8_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PExtended(Right)^; end;
+procedure lpeInt8_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ = PVariant(Right)^; end;
+procedure lpeUInt16_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PUInt8(Right)^; end;
+procedure lpeUInt16_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PInt8(Right)^; end;
+procedure lpeUInt16_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PUInt16(Right)^; end;
+procedure lpeUInt16_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PInt16(Right)^; end;
+procedure lpeUInt16_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PUInt32(Right)^; end;
+procedure lpeUInt16_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PInt32(Right)^; end;
+procedure lpeUInt16_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PUInt64(Right)^; end;
+procedure lpeUInt16_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PInt64(Right)^; end;
+procedure lpeUInt16_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PSingle(Right)^; end;
+procedure lpeUInt16_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PDouble(Right)^; end;
+procedure lpeUInt16_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PCurrency(Right)^; end;
+procedure lpeUInt16_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PExtended(Right)^; end;
+procedure lpeUInt16_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ = PVariant(Right)^; end;
+procedure lpeInt16_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PUInt8(Right)^; end;
+procedure lpeInt16_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PInt8(Right)^; end;
+procedure lpeInt16_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PUInt16(Right)^; end;
+procedure lpeInt16_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PInt16(Right)^; end;
+procedure lpeInt16_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PUInt32(Right)^; end;
+procedure lpeInt16_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PInt32(Right)^; end;
+procedure lpeInt16_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PUInt64(Right)^; end;
+procedure lpeInt16_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PInt64(Right)^; end;
+procedure lpeInt16_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PSingle(Right)^; end;
+procedure lpeInt16_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PDouble(Right)^; end;
+procedure lpeInt16_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PCurrency(Right)^; end;
+procedure lpeInt16_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PExtended(Right)^; end;
+procedure lpeInt16_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ = PVariant(Right)^; end;
+procedure lpeUInt32_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PUInt8(Right)^; end;
+procedure lpeUInt32_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PInt8(Right)^; end;
+procedure lpeUInt32_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PUInt16(Right)^; end;
+procedure lpeUInt32_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PInt16(Right)^; end;
+procedure lpeUInt32_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PUInt32(Right)^; end;
+procedure lpeUInt32_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PInt32(Right)^; end;
+procedure lpeUInt32_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PUInt64(Right)^; end;
+procedure lpeUInt32_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PInt64(Right)^; end;
+procedure lpeUInt32_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PSingle(Right)^; end;
+procedure lpeUInt32_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PDouble(Right)^; end;
+procedure lpeUInt32_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PCurrency(Right)^; end;
+procedure lpeUInt32_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PExtended(Right)^; end;
+procedure lpeUInt32_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ = PVariant(Right)^; end;
+procedure lpeInt32_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PUInt8(Right)^; end;
+procedure lpeInt32_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PInt8(Right)^; end;
+procedure lpeInt32_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PUInt16(Right)^; end;
+procedure lpeInt32_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PInt16(Right)^; end;
+procedure lpeInt32_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PUInt32(Right)^; end;
+procedure lpeInt32_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PInt32(Right)^; end;
+procedure lpeInt32_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PUInt64(Right)^; end;
+procedure lpeInt32_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PInt64(Right)^; end;
+procedure lpeInt32_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PSingle(Right)^; end;
+procedure lpeInt32_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PDouble(Right)^; end;
+procedure lpeInt32_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PCurrency(Right)^; end;
+procedure lpeInt32_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PExtended(Right)^; end;
+procedure lpeInt32_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ = PVariant(Right)^; end;
+procedure lpeUInt64_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PUInt8(Right)^; end;
+procedure lpeUInt64_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PInt8(Right)^; end;
+procedure lpeUInt64_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PUInt16(Right)^; end;
+procedure lpeUInt64_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PInt16(Right)^; end;
+procedure lpeUInt64_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PUInt32(Right)^; end;
+procedure lpeUInt64_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PInt32(Right)^; end;
+procedure lpeUInt64_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PUInt64(Right)^; end;
+procedure lpeUInt64_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PInt64(Right)^; end;
+procedure lpeUInt64_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PSingle(Right)^; end;
+procedure lpeUInt64_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PDouble(Right)^; end;
+procedure lpeUInt64_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PCurrency(Right)^; end;
+procedure lpeUInt64_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PExtended(Right)^; end;
+procedure lpeUInt64_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ = PVariant(Right)^; end;
+procedure lpeInt64_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PUInt8(Right)^; end;
+procedure lpeInt64_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PInt8(Right)^; end;
+procedure lpeInt64_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PUInt16(Right)^; end;
+procedure lpeInt64_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PInt16(Right)^; end;
+procedure lpeInt64_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PUInt32(Right)^; end;
+procedure lpeInt64_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PInt32(Right)^; end;
+procedure lpeInt64_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PUInt64(Right)^; end;
+procedure lpeInt64_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PInt64(Right)^; end;
+procedure lpeInt64_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PSingle(Right)^; end;
+procedure lpeInt64_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PDouble(Right)^; end;
+procedure lpeInt64_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PCurrency(Right)^; end;
+procedure lpeInt64_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PExtended(Right)^; end;
+procedure lpeInt64_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ = PVariant(Right)^; end;
+procedure lpeSingle_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PUInt8(Right)^; end;
+procedure lpeSingle_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PInt8(Right)^; end;
+procedure lpeSingle_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PUInt16(Right)^; end;
+procedure lpeSingle_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PInt16(Right)^; end;
+procedure lpeSingle_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PUInt32(Right)^; end;
+procedure lpeSingle_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PInt32(Right)^; end;
+procedure lpeSingle_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PUInt64(Right)^; end;
+procedure lpeSingle_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PInt64(Right)^; end;
+procedure lpeSingle_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PSingle(Right)^; end;
+procedure lpeSingle_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PDouble(Right)^; end;
+procedure lpeSingle_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PCurrency(Right)^; end;
+procedure lpeSingle_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PExtended(Right)^; end;
+procedure lpeSingle_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ = PVariant(Right)^; end;
+procedure lpeDouble_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PUInt8(Right)^; end;
+procedure lpeDouble_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PInt8(Right)^; end;
+procedure lpeDouble_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PUInt16(Right)^; end;
+procedure lpeDouble_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PInt16(Right)^; end;
+procedure lpeDouble_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PUInt32(Right)^; end;
+procedure lpeDouble_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PInt32(Right)^; end;
+procedure lpeDouble_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PUInt64(Right)^; end;
+procedure lpeDouble_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PInt64(Right)^; end;
+procedure lpeDouble_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PSingle(Right)^; end;
+procedure lpeDouble_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PDouble(Right)^; end;
+procedure lpeDouble_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PCurrency(Right)^; end;
+procedure lpeDouble_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PExtended(Right)^; end;
+procedure lpeDouble_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ = PVariant(Right)^; end;
+procedure lpeCurrency_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PUInt8(Right)^; end;
+procedure lpeCurrency_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PInt8(Right)^; end;
+procedure lpeCurrency_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PUInt16(Right)^; end;
+procedure lpeCurrency_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PInt16(Right)^; end;
+procedure lpeCurrency_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PUInt32(Right)^; end;
+procedure lpeCurrency_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PInt32(Right)^; end;
+procedure lpeCurrency_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PUInt64(Right)^; end;
+procedure lpeCurrency_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PInt64(Right)^; end;
+procedure lpeCurrency_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PSingle(Right)^; end;
+procedure lpeCurrency_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PDouble(Right)^; end;
+procedure lpeCurrency_EQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PCurrency(Right)^; end;
+procedure lpeCurrency_EQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PExtended(Right)^; end;
+procedure lpeCurrency_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ = PVariant(Right)^; end;
+procedure lpeExtended_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PUInt8(Right)^; end;
+procedure lpeExtended_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PInt8(Right)^; end;
+procedure lpeExtended_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PUInt16(Right)^; end;
+procedure lpeExtended_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PInt16(Right)^; end;
+procedure lpeExtended_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PUInt32(Right)^; end;
+procedure lpeExtended_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PInt32(Right)^; end;
+procedure lpeExtended_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PUInt64(Right)^; end;
+procedure lpeExtended_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PInt64(Right)^; end;
+procedure lpeExtended_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PSingle(Right)^; end;
+procedure lpeExtended_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PDouble(Right)^; end;
+procedure lpeExtended_EQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PCurrency(Right)^; end;
+procedure lpeExtended_EQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PExtended(Right)^; end;
+procedure lpeExtended_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ = PVariant(Right)^; end;
+procedure lpeVariant_EQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PUInt8(Right)^; end;
+procedure lpeVariant_EQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PInt8(Right)^; end;
+procedure lpeVariant_EQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PUInt16(Right)^; end;
+procedure lpeVariant_EQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PInt16(Right)^; end;
+procedure lpeVariant_EQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PUInt32(Right)^; end;
+procedure lpeVariant_EQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PInt32(Right)^; end;
+procedure lpeVariant_EQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PUInt64(Right)^; end;
+procedure lpeVariant_EQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PInt64(Right)^; end;
+procedure lpeVariant_EQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PSingle(Right)^; end;
+procedure lpeVariant_EQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PDouble(Right)^; end;
+procedure lpeVariant_EQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PCurrency(Right)^; end;
+procedure lpeVariant_EQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PExtended(Right)^; end;
+procedure lpeVariant_EQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ = PVariant(Right)^; end;
+procedure lpeUInt8_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PUInt8(Right)^; end;
+procedure lpeUInt8_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PInt8(Right)^; end;
+procedure lpeUInt8_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PUInt16(Right)^; end;
+procedure lpeUInt8_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PInt16(Right)^; end;
+procedure lpeUInt8_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PUInt32(Right)^; end;
+procedure lpeUInt8_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PInt32(Right)^; end;
+procedure lpeUInt8_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PUInt64(Right)^; end;
+procedure lpeUInt8_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PInt64(Right)^; end;
+procedure lpeUInt8_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PSingle(Right)^; end;
+procedure lpeUInt8_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PDouble(Right)^; end;
+procedure lpeUInt8_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PCurrency(Right)^; end;
+procedure lpeUInt8_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PExtended(Right)^; end;
+procedure lpeUInt8_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ > PVariant(Right)^; end;
+procedure lpeInt8_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PUInt8(Right)^; end;
+procedure lpeInt8_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PInt8(Right)^; end;
+procedure lpeInt8_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PUInt16(Right)^; end;
+procedure lpeInt8_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PInt16(Right)^; end;
+procedure lpeInt8_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PUInt32(Right)^; end;
+procedure lpeInt8_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PInt32(Right)^; end;
+procedure lpeInt8_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PUInt64(Right)^; end;
+procedure lpeInt8_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PInt64(Right)^; end;
+procedure lpeInt8_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PSingle(Right)^; end;
+procedure lpeInt8_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PDouble(Right)^; end;
+procedure lpeInt8_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PCurrency(Right)^; end;
+procedure lpeInt8_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PExtended(Right)^; end;
+procedure lpeInt8_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ > PVariant(Right)^; end;
+procedure lpeUInt16_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PUInt8(Right)^; end;
+procedure lpeUInt16_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PInt8(Right)^; end;
+procedure lpeUInt16_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PUInt16(Right)^; end;
+procedure lpeUInt16_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PInt16(Right)^; end;
+procedure lpeUInt16_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PUInt32(Right)^; end;
+procedure lpeUInt16_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PInt32(Right)^; end;
+procedure lpeUInt16_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PUInt64(Right)^; end;
+procedure lpeUInt16_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PInt64(Right)^; end;
+procedure lpeUInt16_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PSingle(Right)^; end;
+procedure lpeUInt16_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PDouble(Right)^; end;
+procedure lpeUInt16_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PCurrency(Right)^; end;
+procedure lpeUInt16_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PExtended(Right)^; end;
+procedure lpeUInt16_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ > PVariant(Right)^; end;
+procedure lpeInt16_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PUInt8(Right)^; end;
+procedure lpeInt16_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PInt8(Right)^; end;
+procedure lpeInt16_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PUInt16(Right)^; end;
+procedure lpeInt16_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PInt16(Right)^; end;
+procedure lpeInt16_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PUInt32(Right)^; end;
+procedure lpeInt16_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PInt32(Right)^; end;
+procedure lpeInt16_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PUInt64(Right)^; end;
+procedure lpeInt16_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PInt64(Right)^; end;
+procedure lpeInt16_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PSingle(Right)^; end;
+procedure lpeInt16_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PDouble(Right)^; end;
+procedure lpeInt16_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PCurrency(Right)^; end;
+procedure lpeInt16_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PExtended(Right)^; end;
+procedure lpeInt16_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ > PVariant(Right)^; end;
+procedure lpeUInt32_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PUInt8(Right)^; end;
+procedure lpeUInt32_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PInt8(Right)^; end;
+procedure lpeUInt32_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PUInt16(Right)^; end;
+procedure lpeUInt32_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PInt16(Right)^; end;
+procedure lpeUInt32_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PUInt32(Right)^; end;
+procedure lpeUInt32_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PInt32(Right)^; end;
+procedure lpeUInt32_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PUInt64(Right)^; end;
+procedure lpeUInt32_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PInt64(Right)^; end;
+procedure lpeUInt32_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PSingle(Right)^; end;
+procedure lpeUInt32_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PDouble(Right)^; end;
+procedure lpeUInt32_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PCurrency(Right)^; end;
+procedure lpeUInt32_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PExtended(Right)^; end;
+procedure lpeUInt32_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ > PVariant(Right)^; end;
+procedure lpeInt32_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PUInt8(Right)^; end;
+procedure lpeInt32_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PInt8(Right)^; end;
+procedure lpeInt32_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PUInt16(Right)^; end;
+procedure lpeInt32_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PInt16(Right)^; end;
+procedure lpeInt32_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PUInt32(Right)^; end;
+procedure lpeInt32_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PInt32(Right)^; end;
+procedure lpeInt32_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PUInt64(Right)^; end;
+procedure lpeInt32_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PInt64(Right)^; end;
+procedure lpeInt32_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PSingle(Right)^; end;
+procedure lpeInt32_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PDouble(Right)^; end;
+procedure lpeInt32_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PCurrency(Right)^; end;
+procedure lpeInt32_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PExtended(Right)^; end;
+procedure lpeInt32_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ > PVariant(Right)^; end;
+procedure lpeUInt64_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PUInt8(Right)^; end;
+procedure lpeUInt64_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PInt8(Right)^; end;
+procedure lpeUInt64_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PUInt16(Right)^; end;
+procedure lpeUInt64_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PInt16(Right)^; end;
+procedure lpeUInt64_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PUInt32(Right)^; end;
+procedure lpeUInt64_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PInt32(Right)^; end;
+procedure lpeUInt64_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PUInt64(Right)^; end;
+procedure lpeUInt64_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PInt64(Right)^; end;
+procedure lpeUInt64_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PSingle(Right)^; end;
+procedure lpeUInt64_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PDouble(Right)^; end;
+procedure lpeUInt64_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PCurrency(Right)^; end;
+procedure lpeUInt64_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PExtended(Right)^; end;
+procedure lpeUInt64_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ > PVariant(Right)^; end;
+procedure lpeInt64_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PUInt8(Right)^; end;
+procedure lpeInt64_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PInt8(Right)^; end;
+procedure lpeInt64_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PUInt16(Right)^; end;
+procedure lpeInt64_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PInt16(Right)^; end;
+procedure lpeInt64_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PUInt32(Right)^; end;
+procedure lpeInt64_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PInt32(Right)^; end;
+procedure lpeInt64_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PUInt64(Right)^; end;
+procedure lpeInt64_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PInt64(Right)^; end;
+procedure lpeInt64_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PSingle(Right)^; end;
+procedure lpeInt64_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PDouble(Right)^; end;
+procedure lpeInt64_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PCurrency(Right)^; end;
+procedure lpeInt64_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PExtended(Right)^; end;
+procedure lpeInt64_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ > PVariant(Right)^; end;
+procedure lpeSingle_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PUInt8(Right)^; end;
+procedure lpeSingle_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PInt8(Right)^; end;
+procedure lpeSingle_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PUInt16(Right)^; end;
+procedure lpeSingle_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PInt16(Right)^; end;
+procedure lpeSingle_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PUInt32(Right)^; end;
+procedure lpeSingle_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PInt32(Right)^; end;
+procedure lpeSingle_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PUInt64(Right)^; end;
+procedure lpeSingle_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PInt64(Right)^; end;
+procedure lpeSingle_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PSingle(Right)^; end;
+procedure lpeSingle_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PDouble(Right)^; end;
+procedure lpeSingle_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PCurrency(Right)^; end;
+procedure lpeSingle_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PExtended(Right)^; end;
+procedure lpeSingle_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ > PVariant(Right)^; end;
+procedure lpeDouble_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PUInt8(Right)^; end;
+procedure lpeDouble_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PInt8(Right)^; end;
+procedure lpeDouble_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PUInt16(Right)^; end;
+procedure lpeDouble_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PInt16(Right)^; end;
+procedure lpeDouble_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PUInt32(Right)^; end;
+procedure lpeDouble_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PInt32(Right)^; end;
+procedure lpeDouble_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PUInt64(Right)^; end;
+procedure lpeDouble_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PInt64(Right)^; end;
+procedure lpeDouble_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PSingle(Right)^; end;
+procedure lpeDouble_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PDouble(Right)^; end;
+procedure lpeDouble_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PCurrency(Right)^; end;
+procedure lpeDouble_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PExtended(Right)^; end;
+procedure lpeDouble_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ > PVariant(Right)^; end;
+procedure lpeCurrency_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PUInt8(Right)^; end;
+procedure lpeCurrency_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PInt8(Right)^; end;
+procedure lpeCurrency_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PUInt16(Right)^; end;
+procedure lpeCurrency_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PInt16(Right)^; end;
+procedure lpeCurrency_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PUInt32(Right)^; end;
+procedure lpeCurrency_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PInt32(Right)^; end;
+procedure lpeCurrency_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PUInt64(Right)^; end;
+procedure lpeCurrency_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PInt64(Right)^; end;
+procedure lpeCurrency_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PSingle(Right)^; end;
+procedure lpeCurrency_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PDouble(Right)^; end;
+procedure lpeCurrency_GT_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PCurrency(Right)^; end;
+procedure lpeCurrency_GT_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PExtended(Right)^; end;
+procedure lpeCurrency_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ > PVariant(Right)^; end;
+procedure lpeExtended_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PUInt8(Right)^; end;
+procedure lpeExtended_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PInt8(Right)^; end;
+procedure lpeExtended_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PUInt16(Right)^; end;
+procedure lpeExtended_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PInt16(Right)^; end;
+procedure lpeExtended_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PUInt32(Right)^; end;
+procedure lpeExtended_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PInt32(Right)^; end;
+procedure lpeExtended_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PUInt64(Right)^; end;
+procedure lpeExtended_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PInt64(Right)^; end;
+procedure lpeExtended_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PSingle(Right)^; end;
+procedure lpeExtended_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PDouble(Right)^; end;
+procedure lpeExtended_GT_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PCurrency(Right)^; end;
+procedure lpeExtended_GT_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PExtended(Right)^; end;
+procedure lpeExtended_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ > PVariant(Right)^; end;
+procedure lpeVariant_GT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PUInt8(Right)^; end;
+procedure lpeVariant_GT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PInt8(Right)^; end;
+procedure lpeVariant_GT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PUInt16(Right)^; end;
+procedure lpeVariant_GT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PInt16(Right)^; end;
+procedure lpeVariant_GT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PUInt32(Right)^; end;
+procedure lpeVariant_GT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PInt32(Right)^; end;
+procedure lpeVariant_GT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PUInt64(Right)^; end;
+procedure lpeVariant_GT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PInt64(Right)^; end;
+procedure lpeVariant_GT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PSingle(Right)^; end;
+procedure lpeVariant_GT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PDouble(Right)^; end;
+procedure lpeVariant_GT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PCurrency(Right)^; end;
+procedure lpeVariant_GT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PExtended(Right)^; end;
+procedure lpeVariant_GT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ > PVariant(Right)^; end;
+procedure lpeUInt8_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PUInt8(Right)^; end;
+procedure lpeUInt8_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PInt8(Right)^; end;
+procedure lpeUInt8_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PUInt16(Right)^; end;
+procedure lpeUInt8_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PInt16(Right)^; end;
+procedure lpeUInt8_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PUInt32(Right)^; end;
+procedure lpeUInt8_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PInt32(Right)^; end;
+procedure lpeUInt8_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PUInt64(Right)^; end;
+procedure lpeUInt8_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PInt64(Right)^; end;
+procedure lpeUInt8_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PSingle(Right)^; end;
+procedure lpeUInt8_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PDouble(Right)^; end;
+procedure lpeUInt8_GTEQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PCurrency(Right)^; end;
+procedure lpeUInt8_GTEQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PExtended(Right)^; end;
+procedure lpeUInt8_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ >= PVariant(Right)^; end;
+procedure lpeInt8_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PUInt8(Right)^; end;
+procedure lpeInt8_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PInt8(Right)^; end;
+procedure lpeInt8_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PUInt16(Right)^; end;
+procedure lpeInt8_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PInt16(Right)^; end;
+procedure lpeInt8_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PUInt32(Right)^; end;
+procedure lpeInt8_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PInt32(Right)^; end;
+procedure lpeInt8_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PUInt64(Right)^; end;
+procedure lpeInt8_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PInt64(Right)^; end;
+procedure lpeInt8_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PSingle(Right)^; end;
+procedure lpeInt8_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PDouble(Right)^; end;
+procedure lpeInt8_GTEQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PCurrency(Right)^; end;
+procedure lpeInt8_GTEQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PExtended(Right)^; end;
+procedure lpeInt8_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ >= PVariant(Right)^; end;
+procedure lpeUInt16_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PUInt8(Right)^; end;
+procedure lpeUInt16_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PInt8(Right)^; end;
+procedure lpeUInt16_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PUInt16(Right)^; end;
+procedure lpeUInt16_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PInt16(Right)^; end;
+procedure lpeUInt16_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PUInt32(Right)^; end;
+procedure lpeUInt16_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PInt32(Right)^; end;
+procedure lpeUInt16_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PUInt64(Right)^; end;
+procedure lpeUInt16_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PInt64(Right)^; end;
+procedure lpeUInt16_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PSingle(Right)^; end;
+procedure lpeUInt16_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PDouble(Right)^; end;
+procedure lpeUInt16_GTEQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PCurrency(Right)^; end;
+procedure lpeUInt16_GTEQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PExtended(Right)^; end;
+procedure lpeUInt16_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ >= PVariant(Right)^; end;
+procedure lpeInt16_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PUInt8(Right)^; end;
+procedure lpeInt16_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PInt8(Right)^; end;
+procedure lpeInt16_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PUInt16(Right)^; end;
+procedure lpeInt16_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PInt16(Right)^; end;
+procedure lpeInt16_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PUInt32(Right)^; end;
+procedure lpeInt16_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PInt32(Right)^; end;
+procedure lpeInt16_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PUInt64(Right)^; end;
+procedure lpeInt16_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PInt64(Right)^; end;
+procedure lpeInt16_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PSingle(Right)^; end;
+procedure lpeInt16_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PDouble(Right)^; end;
+procedure lpeInt16_GTEQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PCurrency(Right)^; end;
+procedure lpeInt16_GTEQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PExtended(Right)^; end;
+procedure lpeInt16_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ >= PVariant(Right)^; end;
+procedure lpeUInt32_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PUInt8(Right)^; end;
+procedure lpeUInt32_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PInt8(Right)^; end;
+procedure lpeUInt32_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PUInt16(Right)^; end;
+procedure lpeUInt32_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PInt16(Right)^; end;
+procedure lpeUInt32_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PUInt32(Right)^; end;
+procedure lpeUInt32_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PInt32(Right)^; end;
+procedure lpeUInt32_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PUInt64(Right)^; end;
+procedure lpeUInt32_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PInt64(Right)^; end;
+procedure lpeUInt32_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PSingle(Right)^; end;
+procedure lpeUInt32_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PDouble(Right)^; end;
+procedure lpeUInt32_GTEQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PCurrency(Right)^; end;
+procedure lpeUInt32_GTEQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PExtended(Right)^; end;
+procedure lpeUInt32_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ >= PVariant(Right)^; end;
+procedure lpeInt32_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PUInt8(Right)^; end;
+procedure lpeInt32_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PInt8(Right)^; end;
+procedure lpeInt32_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PUInt16(Right)^; end;
+procedure lpeInt32_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PInt16(Right)^; end;
+procedure lpeInt32_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PUInt32(Right)^; end;
+procedure lpeInt32_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PInt32(Right)^; end;
+procedure lpeInt32_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PUInt64(Right)^; end;
+procedure lpeInt32_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PInt64(Right)^; end;
+procedure lpeInt32_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PSingle(Right)^; end;
+procedure lpeInt32_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PDouble(Right)^; end;
+procedure lpeInt32_GTEQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PCurrency(Right)^; end;
+procedure lpeInt32_GTEQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PExtended(Right)^; end;
+procedure lpeInt32_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ >= PVariant(Right)^; end;
+procedure lpeUInt64_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PUInt8(Right)^; end;
+procedure lpeUInt64_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PInt8(Right)^; end;
+procedure lpeUInt64_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PUInt16(Right)^; end;
+procedure lpeUInt64_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PInt16(Right)^; end;
+procedure lpeUInt64_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PUInt32(Right)^; end;
+procedure lpeUInt64_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PInt32(Right)^; end;
+procedure lpeUInt64_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PUInt64(Right)^; end;
+procedure lpeUInt64_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PInt64(Right)^; end;
+procedure lpeUInt64_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PSingle(Right)^; end;
+procedure lpeUInt64_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PDouble(Right)^; end;
+procedure lpeUInt64_GTEQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PCurrency(Right)^; end;
+procedure lpeUInt64_GTEQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PExtended(Right)^; end;
+procedure lpeUInt64_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ >= PVariant(Right)^; end;
+procedure lpeInt64_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PUInt8(Right)^; end;
+procedure lpeInt64_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PInt8(Right)^; end;
+procedure lpeInt64_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PUInt16(Right)^; end;
+procedure lpeInt64_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PInt16(Right)^; end;
+procedure lpeInt64_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PUInt32(Right)^; end;
+procedure lpeInt64_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PInt32(Right)^; end;
+procedure lpeInt64_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PUInt64(Right)^; end;
+procedure lpeInt64_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PInt64(Right)^; end;
+procedure lpeInt64_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PSingle(Right)^; end;
+procedure lpeInt64_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PDouble(Right)^; end;
+procedure lpeInt64_GTEQ_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PCurrency(Right)^; end;
+procedure lpeInt64_GTEQ_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PExtended(Right)^; end;
+procedure lpeInt64_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ >= PVariant(Right)^; end;
+procedure lpeSingle_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PUInt8(Right)^; end;
+procedure lpeSingle_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PInt8(Right)^; end;
+procedure lpeSingle_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PUInt16(Right)^; end;
+procedure lpeSingle_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PInt16(Right)^; end;
+procedure lpeSingle_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PUInt32(Right)^; end;
+procedure lpeSingle_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PInt32(Right)^; end;
+procedure lpeSingle_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PUInt64(Right)^; end;
+procedure lpeSingle_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PInt64(Right)^; end;
+procedure lpeSingle_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PSingle(Right)^; end;
+procedure lpeSingle_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PDouble(Right)^; end;
+procedure lpeSingle_GTEQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PCurrency(Right)^; end;
+procedure lpeSingle_GTEQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PExtended(Right)^; end;
+procedure lpeSingle_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ >= PVariant(Right)^; end;
+procedure lpeDouble_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PUInt8(Right)^; end;
+procedure lpeDouble_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PInt8(Right)^; end;
+procedure lpeDouble_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PUInt16(Right)^; end;
+procedure lpeDouble_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PInt16(Right)^; end;
+procedure lpeDouble_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PUInt32(Right)^; end;
+procedure lpeDouble_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PInt32(Right)^; end;
+procedure lpeDouble_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PUInt64(Right)^; end;
+procedure lpeDouble_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PInt64(Right)^; end;
+procedure lpeDouble_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PSingle(Right)^; end;
+procedure lpeDouble_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PDouble(Right)^; end;
+procedure lpeDouble_GTEQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PCurrency(Right)^; end;
+procedure lpeDouble_GTEQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PExtended(Right)^; end;
+procedure lpeDouble_GTEQ_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ >= PVariant(Right)^; end;
+procedure lpeCurrency_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PUInt8(Right)^; end;
+procedure lpeCurrency_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PInt8(Right)^; end;
+procedure lpeCurrency_GTEQ_UInt16(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PUInt16(Right)^; end;
+procedure lpeCurrency_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PInt16(Right)^; end;
+procedure lpeCurrency_GTEQ_UInt32(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PUInt32(Right)^; end;
+procedure lpeCurrency_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PInt32(Right)^; end;
+procedure lpeCurrency_GTEQ_UInt64(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PUInt64(Right)^; end;
+procedure lpeCurrency_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PInt64(Right)^; end;
+procedure lpeCurrency_GTEQ_Single(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PSingle(Right)^; end;
+procedure lpeCurrency_GTEQ_Double(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PDouble(Right)^; end;
+procedure lpeCurrency_GTEQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PCurrency(Right)^; end;
+procedure lpeCurrency_GTEQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PExtended(Right)^; end;
+procedure lpeCurrency_GTEQ_Variant(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ >= PVariant(Right)^; end;
+procedure lpeExtended_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PUInt8(Right)^; end;
+procedure lpeExtended_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PInt8(Right)^; end;
+procedure lpeExtended_GTEQ_UInt16(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PUInt16(Right)^; end;
+procedure lpeExtended_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PInt16(Right)^; end;
+procedure lpeExtended_GTEQ_UInt32(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PUInt32(Right)^; end;
+procedure lpeExtended_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PInt32(Right)^; end;
+procedure lpeExtended_GTEQ_UInt64(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PUInt64(Right)^; end;
+procedure lpeExtended_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PInt64(Right)^; end;
+procedure lpeExtended_GTEQ_Single(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PSingle(Right)^; end;
+procedure lpeExtended_GTEQ_Double(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PDouble(Right)^; end;
+procedure lpeExtended_GTEQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PCurrency(Right)^; end;
+procedure lpeExtended_GTEQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PExtended(Right)^; end;
+procedure lpeExtended_GTEQ_Variant(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ >= PVariant(Right)^; end;
+procedure lpeVariant_GTEQ_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PUInt8(Right)^; end;
+procedure lpeVariant_GTEQ_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PInt8(Right)^; end;
+procedure lpeVariant_GTEQ_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PUInt16(Right)^; end;
+procedure lpeVariant_GTEQ_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PInt16(Right)^; end;
+procedure lpeVariant_GTEQ_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PUInt32(Right)^; end;
+procedure lpeVariant_GTEQ_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PInt32(Right)^; end;
+procedure lpeVariant_GTEQ_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PUInt64(Right)^; end;
+procedure lpeVariant_GTEQ_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PInt64(Right)^; end;
+procedure lpeVariant_GTEQ_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PSingle(Right)^; end;
+procedure lpeVariant_GTEQ_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PDouble(Right)^; end;
+procedure lpeVariant_GTEQ_Currency(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PCurrency(Right)^; end;
+procedure lpeVariant_GTEQ_Extended(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PExtended(Right)^; end;
+procedure lpeVariant_GTEQ_Variant(const Dest, Left, Right: Pointer);
+lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ >= PVariant(Right)^; end;
+procedure lpeUInt8_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PUInt8(Right)^; end;
+procedure lpeUInt8_LT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PInt8(Right)^; end;
+procedure lpeUInt8_LT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PUInt16(Right)^; end;
+procedure lpeUInt8_LT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PInt16(Right)^; end;
+procedure lpeUInt8_LT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PUInt32(Right)^; end;
+procedure lpeUInt8_LT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PInt32(Right)^; end;
+procedure lpeUInt8_LT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PUInt64(Right)^; end;
+procedure lpeUInt8_LT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PInt64(Right)^; end;
+procedure lpeUInt8_LT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PSingle(Right)^; end;
+procedure lpeUInt8_LT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PDouble(Right)^; end;
+procedure lpeUInt8_LT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PCurrency(Right)^; end;
+procedure lpeUInt8_LT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PExtended(Right)^; end;
+procedure lpeUInt8_LT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ < PVariant(Right)^; end;
+procedure lpeInt8_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PUInt8(Right)^; end;
+procedure lpeInt8_LT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PInt8(Right)^; end;
+procedure lpeInt8_LT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PUInt16(Right)^; end;
+procedure lpeInt8_LT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PInt16(Right)^; end;
+procedure lpeInt8_LT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PUInt32(Right)^; end;
+procedure lpeInt8_LT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PInt32(Right)^; end;
+procedure lpeInt8_LT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PUInt64(Right)^; end;
+procedure lpeInt8_LT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PInt64(Right)^; end;
+procedure lpeInt8_LT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PSingle(Right)^; end;
+procedure lpeInt8_LT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PDouble(Right)^; end;
+procedure lpeInt8_LT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PCurrency(Right)^; end;
+procedure lpeInt8_LT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PExtended(Right)^; end;
+procedure lpeInt8_LT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ < PVariant(Right)^; end;
+procedure lpeUInt16_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PUInt8(Right)^; end;
+procedure lpeUInt16_LT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PInt8(Right)^; end;
+procedure lpeUInt16_LT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PUInt16(Right)^; end;
+procedure lpeUInt16_LT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PInt16(Right)^; end;
+procedure lpeUInt16_LT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PUInt32(Right)^; end;
+procedure lpeUInt16_LT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PInt32(Right)^; end;
+procedure lpeUInt16_LT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PUInt64(Right)^; end;
+procedure lpeUInt16_LT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PInt64(Right)^; end;
+procedure lpeUInt16_LT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PSingle(Right)^; end;
+procedure lpeUInt16_LT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PDouble(Right)^; end;
+procedure lpeUInt16_LT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PCurrency(Right)^; end;
+procedure lpeUInt16_LT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PExtended(Right)^; end;
+procedure lpeUInt16_LT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ < PVariant(Right)^; end;
+procedure lpeInt16_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PUInt8(Right)^; end;
+procedure lpeInt16_LT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PInt8(Right)^; end;
+procedure lpeInt16_LT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PUInt16(Right)^; end;
+procedure lpeInt16_LT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PInt16(Right)^; end;
+procedure lpeInt16_LT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PUInt32(Right)^; end;
+procedure lpeInt16_LT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PInt32(Right)^; end;
+procedure lpeInt16_LT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PUInt64(Right)^; end;
+procedure lpeInt16_LT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PInt64(Right)^; end;
+procedure lpeInt16_LT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PSingle(Right)^; end;
+procedure lpeInt16_LT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PDouble(Right)^; end;
+procedure lpeInt16_LT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PCurrency(Right)^; end;
+procedure lpeInt16_LT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PExtended(Right)^; end;
+procedure lpeInt16_LT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ < PVariant(Right)^; end;
+procedure lpeUInt32_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PUInt8(Right)^; end;
+procedure lpeUInt32_LT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PInt8(Right)^; end;
+procedure lpeUInt32_LT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PUInt16(Right)^; end;
+procedure lpeUInt32_LT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PInt16(Right)^; end;
+procedure lpeUInt32_LT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PUInt32(Right)^; end;
+procedure lpeUInt32_LT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PInt32(Right)^; end;
+procedure lpeUInt32_LT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PUInt64(Right)^; end;
+procedure lpeUInt32_LT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PInt64(Right)^; end;
+procedure lpeUInt32_LT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PSingle(Right)^; end;
+procedure lpeUInt32_LT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PDouble(Right)^; end;
+procedure lpeUInt32_LT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PCurrency(Right)^; end;
+procedure lpeUInt32_LT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PExtended(Right)^; end;
+procedure lpeUInt32_LT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ < PVariant(Right)^; end;
+procedure lpeInt32_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PUInt8(Right)^; end;
+procedure lpeInt32_LT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PInt8(Right)^; end;
+procedure lpeInt32_LT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PUInt16(Right)^; end;
+procedure lpeInt32_LT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PInt16(Right)^; end;
+procedure lpeInt32_LT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PUInt32(Right)^; end;
+procedure lpeInt32_LT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PInt32(Right)^; end;
+procedure lpeInt32_LT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PUInt64(Right)^; end;
+procedure lpeInt32_LT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PInt64(Right)^; end;
+procedure lpeInt32_LT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PSingle(Right)^; end;
+procedure lpeInt32_LT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PDouble(Right)^; end;
+procedure lpeInt32_LT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PCurrency(Right)^; end;
+procedure lpeInt32_LT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PExtended(Right)^; end;
+procedure lpeInt32_LT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ < PVariant(Right)^; end;
+procedure lpeUInt64_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PUInt8(Right)^; end;
+procedure lpeUInt64_LT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PInt8(Right)^; end;
+procedure lpeUInt64_LT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PUInt16(Right)^; end;
+procedure lpeUInt64_LT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PInt16(Right)^; end;
+procedure lpeUInt64_LT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PUInt32(Right)^; end;
+procedure lpeUInt64_LT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PInt32(Right)^; end;
+procedure lpeUInt64_LT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PUInt64(Right)^; end;
+procedure lpeUInt64_LT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PInt64(Right)^; end;
+procedure lpeUInt64_LT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PSingle(Right)^; end;
+procedure lpeUInt64_LT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PDouble(Right)^; end;
+procedure lpeUInt64_LT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PCurrency(Right)^; end;
+procedure lpeUInt64_LT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PExtended(Right)^; end;
+procedure lpeUInt64_LT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ < PVariant(Right)^; end;
+procedure lpeInt64_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PUInt8(Right)^; end;
+procedure lpeInt64_LT_Int8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PInt8(Right)^; end;
+procedure lpeInt64_LT_UInt16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PUInt16(Right)^; end;
+procedure lpeInt64_LT_Int16(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PInt16(Right)^; end;
+procedure lpeInt64_LT_UInt32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PUInt32(Right)^; end;
+procedure lpeInt64_LT_Int32(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PInt32(Right)^; end;
+procedure lpeInt64_LT_UInt64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PUInt64(Right)^; end;
+procedure lpeInt64_LT_Int64(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PInt64(Right)^; end;
+procedure lpeInt64_LT_Single(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PSingle(Right)^; end;
+procedure lpeInt64_LT_Double(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PDouble(Right)^; end;
+procedure lpeInt64_LT_Currency(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PCurrency(Right)^; end;
+procedure lpeInt64_LT_Extended(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PExtended(Right)^; end;
+procedure lpeInt64_LT_Variant(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ < PVariant(Right)^; end;
+procedure lpeSingle_LT_UInt8(const Dest, Left, Right: Pointer); lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PUInt8(Right)^; end;
+procedure lpeSingle_LT_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PInt8(Right)^; end;
+procedure lpeSingle_LT_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PUInt16(Right)^; end;
+procedure lpeSingle_LT_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PInt16(Right)^; end;
+procedure lpeSingle_LT_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PUInt32(Right)^; end;
+procedure lpeSingle_LT_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PInt32(Right)^; end;
+procedure lpeSingle_LT_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PUInt64(Right)^; end;
+procedure lpeSingle_LT_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PInt64(Right)^; end;
+procedure lpeSingle_LT_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PSingle(Right)^; end;
+procedure lpeSingle_LT_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PDouble(Right)^; end;
+procedure lpeSingle_LT_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PCurrency(Right)^; end;
+procedure lpeSingle_LT_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PExtended(Right)^; end;
+procedure lpeSingle_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ < PVariant(Right)^; end;
+procedure lpeDouble_LT_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PUInt8(Right)^; end;
+procedure lpeDouble_LT_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PInt8(Right)^; end;
+procedure lpeDouble_LT_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PUInt16(Right)^; end;
+procedure lpeDouble_LT_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PInt16(Right)^; end;
+procedure lpeDouble_LT_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PUInt32(Right)^; end;
+procedure lpeDouble_LT_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PInt32(Right)^; end;
+procedure lpeDouble_LT_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PUInt64(Right)^; end;
+procedure lpeDouble_LT_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PInt64(Right)^; end;
+procedure lpeDouble_LT_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PSingle(Right)^; end;
+procedure lpeDouble_LT_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PDouble(Right)^; end;
+procedure lpeDouble_LT_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PCurrency(Right)^; end;
+procedure lpeDouble_LT_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PExtended(Right)^; end;
+procedure lpeDouble_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ < PVariant(Right)^; end;
+procedure lpeCurrency_LT_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PUInt8(Right)^; end;
+procedure lpeCurrency_LT_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PInt8(Right)^; end;
+procedure lpeCurrency_LT_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PUInt16(Right)^; end;
+procedure lpeCurrency_LT_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PInt16(Right)^; end;
+procedure lpeCurrency_LT_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PUInt32(Right)^; end;
+procedure lpeCurrency_LT_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PInt32(Right)^; end;
+procedure lpeCurrency_LT_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PUInt64(Right)^; end;
+procedure lpeCurrency_LT_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PInt64(Right)^; end;
+procedure lpeCurrency_LT_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PSingle(Right)^; end;
+procedure lpeCurrency_LT_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PDouble(Right)^; end;
+procedure lpeCurrency_LT_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PCurrency(Right)^; end;
+procedure lpeCurrency_LT_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PExtended(Right)^; end;
+procedure lpeCurrency_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ < PVariant(Right)^; end;
+procedure lpeExtended_LT_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PUInt8(Right)^; end;
+procedure lpeExtended_LT_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PInt8(Right)^; end;
+procedure lpeExtended_LT_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PUInt16(Right)^; end;
+procedure lpeExtended_LT_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PInt16(Right)^; end;
+procedure lpeExtended_LT_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PUInt32(Right)^; end;
+procedure lpeExtended_LT_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PInt32(Right)^; end;
+procedure lpeExtended_LT_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PUInt64(Right)^; end;
+procedure lpeExtended_LT_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PInt64(Right)^; end;
+procedure lpeExtended_LT_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PSingle(Right)^; end;
+procedure lpeExtended_LT_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PDouble(Right)^; end;
+procedure lpeExtended_LT_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PCurrency(Right)^; end;
+procedure lpeExtended_LT_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PExtended(Right)^; end;
+procedure lpeExtended_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ < PVariant(Right)^; end;
+procedure lpeVariant_LT_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PUInt8(Right)^; end;
+procedure lpeVariant_LT_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PInt8(Right)^; end;
+procedure lpeVariant_LT_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PUInt16(Right)^; end;
+procedure lpeVariant_LT_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PInt16(Right)^; end;
+procedure lpeVariant_LT_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PUInt32(Right)^; end;
+procedure lpeVariant_LT_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PInt32(Right)^; end;
+procedure lpeVariant_LT_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PUInt64(Right)^; end;
+procedure lpeVariant_LT_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PInt64(Right)^; end;
+procedure lpeVariant_LT_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PSingle(Right)^; end;
+procedure lpeVariant_LT_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PDouble(Right)^; end;
+procedure lpeVariant_LT_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PCurrency(Right)^; end;
+procedure lpeVariant_LT_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PExtended(Right)^; end;
+procedure lpeVariant_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ < PVariant(Right)^; end;
+procedure lpeUInt8_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PUInt8(Right)^; end;
+procedure lpeUInt8_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PInt8(Right)^; end;
+procedure lpeUInt8_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PUInt16(Right)^; end;
+procedure lpeUInt8_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PInt16(Right)^; end;
+procedure lpeUInt8_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PUInt32(Right)^; end;
+procedure lpeUInt8_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PInt32(Right)^; end;
+procedure lpeUInt8_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PUInt64(Right)^; end;
+procedure lpeUInt8_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PInt64(Right)^; end;
+procedure lpeUInt8_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PSingle(Right)^; end;
+procedure lpeUInt8_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PDouble(Right)^; end;
+procedure lpeUInt8_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PCurrency(Right)^; end;
+procedure lpeUInt8_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PExtended(Right)^; end;
+procedure lpeUInt8_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <= PVariant(Right)^; end;
+procedure lpeInt8_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PUInt8(Right)^; end;
+procedure lpeInt8_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PInt8(Right)^; end;
+procedure lpeInt8_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PUInt16(Right)^; end;
+procedure lpeInt8_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PInt16(Right)^; end;
+procedure lpeInt8_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PUInt32(Right)^; end;
+procedure lpeInt8_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PInt32(Right)^; end;
+procedure lpeInt8_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PUInt64(Right)^; end;
+procedure lpeInt8_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PInt64(Right)^; end;
+procedure lpeInt8_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PSingle(Right)^; end;
+procedure lpeInt8_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PDouble(Right)^; end;
+procedure lpeInt8_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PCurrency(Right)^; end;
+procedure lpeInt8_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PExtended(Right)^; end;
+procedure lpeInt8_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <= PVariant(Right)^; end;
+procedure lpeUInt16_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PUInt8(Right)^; end;
+procedure lpeUInt16_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PInt8(Right)^; end;
+procedure lpeUInt16_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PUInt16(Right)^; end;
+procedure lpeUInt16_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PInt16(Right)^; end;
+procedure lpeUInt16_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PUInt32(Right)^; end;
+procedure lpeUInt16_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PInt32(Right)^; end;
+procedure lpeUInt16_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PUInt64(Right)^; end;
+procedure lpeUInt16_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PInt64(Right)^; end;
+procedure lpeUInt16_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PSingle(Right)^; end;
+procedure lpeUInt16_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PDouble(Right)^; end;
+procedure lpeUInt16_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PCurrency(Right)^; end;
+procedure lpeUInt16_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PExtended(Right)^; end;
+procedure lpeUInt16_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <= PVariant(Right)^; end;
+procedure lpeInt16_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PUInt8(Right)^; end;
+procedure lpeInt16_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PInt8(Right)^; end;
+procedure lpeInt16_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PUInt16(Right)^; end;
+procedure lpeInt16_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PInt16(Right)^; end;
+procedure lpeInt16_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PUInt32(Right)^; end;
+procedure lpeInt16_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PInt32(Right)^; end;
+procedure lpeInt16_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PUInt64(Right)^; end;
+procedure lpeInt16_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PInt64(Right)^; end;
+procedure lpeInt16_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PSingle(Right)^; end;
+procedure lpeInt16_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PDouble(Right)^; end;
+procedure lpeInt16_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PCurrency(Right)^; end;
+procedure lpeInt16_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PExtended(Right)^; end;
+procedure lpeInt16_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <= PVariant(Right)^; end;
+procedure lpeUInt32_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PUInt8(Right)^; end;
+procedure lpeUInt32_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PInt8(Right)^; end;
+procedure lpeUInt32_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PUInt16(Right)^; end;
+procedure lpeUInt32_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PInt16(Right)^; end;
+procedure lpeUInt32_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PUInt32(Right)^; end;
+procedure lpeUInt32_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PInt32(Right)^; end;
+procedure lpeUInt32_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PUInt64(Right)^; end;
+procedure lpeUInt32_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PInt64(Right)^; end;
+procedure lpeUInt32_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PSingle(Right)^; end;
+procedure lpeUInt32_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PDouble(Right)^; end;
+procedure lpeUInt32_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PCurrency(Right)^; end;
+procedure lpeUInt32_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PExtended(Right)^; end;
+procedure lpeUInt32_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <= PVariant(Right)^; end;
+procedure lpeInt32_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PUInt8(Right)^; end;
+procedure lpeInt32_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PInt8(Right)^; end;
+procedure lpeInt32_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PUInt16(Right)^; end;
+procedure lpeInt32_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PInt16(Right)^; end;
+procedure lpeInt32_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PUInt32(Right)^; end;
+procedure lpeInt32_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PInt32(Right)^; end;
+procedure lpeInt32_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PUInt64(Right)^; end;
+procedure lpeInt32_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PInt64(Right)^; end;
+procedure lpeInt32_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PSingle(Right)^; end;
+procedure lpeInt32_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PDouble(Right)^; end;
+procedure lpeInt32_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PCurrency(Right)^; end;
+procedure lpeInt32_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PExtended(Right)^; end;
+procedure lpeInt32_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <= PVariant(Right)^; end;
+procedure lpeUInt64_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PUInt8(Right)^; end;
+procedure lpeUInt64_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PInt8(Right)^; end;
+procedure lpeUInt64_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PUInt16(Right)^; end;
+procedure lpeUInt64_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PInt16(Right)^; end;
+procedure lpeUInt64_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PUInt32(Right)^; end;
+procedure lpeUInt64_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PInt32(Right)^; end;
+procedure lpeUInt64_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PUInt64(Right)^; end;
+procedure lpeUInt64_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PInt64(Right)^; end;
+procedure lpeUInt64_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PSingle(Right)^; end;
+procedure lpeUInt64_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PDouble(Right)^; end;
+procedure lpeUInt64_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PCurrency(Right)^; end;
+procedure lpeUInt64_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PExtended(Right)^; end;
+procedure lpeUInt64_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <= PVariant(Right)^; end;
+procedure lpeInt64_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PUInt8(Right)^; end;
+procedure lpeInt64_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PInt8(Right)^; end;
+procedure lpeInt64_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PUInt16(Right)^; end;
+procedure lpeInt64_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PInt16(Right)^; end;
+procedure lpeInt64_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PUInt32(Right)^; end;
+procedure lpeInt64_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PInt32(Right)^; end;
+procedure lpeInt64_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PUInt64(Right)^; end;
+procedure lpeInt64_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PInt64(Right)^; end;
+procedure lpeInt64_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PSingle(Right)^; end;
+procedure lpeInt64_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PDouble(Right)^; end;
+procedure lpeInt64_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PCurrency(Right)^; end;
+procedure lpeInt64_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PExtended(Right)^; end;
+procedure lpeInt64_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <= PVariant(Right)^; end;
+procedure lpeSingle_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PUInt8(Right)^; end;
+procedure lpeSingle_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PInt8(Right)^; end;
+procedure lpeSingle_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PUInt16(Right)^; end;
+procedure lpeSingle_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PInt16(Right)^; end;
+procedure lpeSingle_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PUInt32(Right)^; end;
+procedure lpeSingle_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PInt32(Right)^; end;
+procedure lpeSingle_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PUInt64(Right)^; end;
+procedure lpeSingle_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PInt64(Right)^; end;
+procedure lpeSingle_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PSingle(Right)^; end;
+procedure lpeSingle_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PDouble(Right)^; end;
+procedure lpeSingle_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PCurrency(Right)^; end;
+procedure lpeSingle_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PExtended(Right)^; end;
+procedure lpeSingle_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <= PVariant(Right)^; end;
+procedure lpeDouble_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PUInt8(Right)^; end;
+procedure lpeDouble_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PInt8(Right)^; end;
+procedure lpeDouble_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PUInt16(Right)^; end;
+procedure lpeDouble_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PInt16(Right)^; end;
+procedure lpeDouble_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PUInt32(Right)^; end;
+procedure lpeDouble_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PInt32(Right)^; end;
+procedure lpeDouble_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PUInt64(Right)^; end;
+procedure lpeDouble_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PInt64(Right)^; end;
+procedure lpeDouble_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PSingle(Right)^; end;
+procedure lpeDouble_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PDouble(Right)^; end;
+procedure lpeDouble_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PCurrency(Right)^; end;
+procedure lpeDouble_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PExtended(Right)^; end;
+procedure lpeDouble_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <= PVariant(Right)^; end;
+procedure lpeCurrency_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PUInt8(Right)^; end;
+procedure lpeCurrency_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PInt8(Right)^; end;
+procedure lpeCurrency_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PUInt16(Right)^; end;
+procedure lpeCurrency_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PInt16(Right)^; end;
+procedure lpeCurrency_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PUInt32(Right)^; end;
+procedure lpeCurrency_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PInt32(Right)^; end;
+procedure lpeCurrency_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PUInt64(Right)^; end;
+procedure lpeCurrency_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PInt64(Right)^; end;
+procedure lpeCurrency_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PSingle(Right)^; end;
+procedure lpeCurrency_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PDouble(Right)^; end;
+procedure lpeCurrency_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PCurrency(Right)^; end;
+procedure lpeCurrency_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PExtended(Right)^; end;
+procedure lpeCurrency_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <= PVariant(Right)^; end;
+procedure lpeExtended_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PUInt8(Right)^; end;
+procedure lpeExtended_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PInt8(Right)^; end;
+procedure lpeExtended_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PUInt16(Right)^; end;
+procedure lpeExtended_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PInt16(Right)^; end;
+procedure lpeExtended_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PUInt32(Right)^; end;
+procedure lpeExtended_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PInt32(Right)^; end;
+procedure lpeExtended_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PUInt64(Right)^; end;
+procedure lpeExtended_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PInt64(Right)^; end;
+procedure lpeExtended_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PSingle(Right)^; end;
+procedure lpeExtended_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PDouble(Right)^; end;
+procedure lpeExtended_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PCurrency(Right)^; end;
+procedure lpeExtended_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PExtended(Right)^; end;
+procedure lpeExtended_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <= PVariant(Right)^; end;
+procedure lpeVariant_LTEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PUInt8(Right)^; end;
+procedure lpeVariant_LTEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PInt8(Right)^; end;
+procedure lpeVariant_LTEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PUInt16(Right)^; end;
+procedure lpeVariant_LTEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PInt16(Right)^; end;
+procedure lpeVariant_LTEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PUInt32(Right)^; end;
+procedure lpeVariant_LTEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PInt32(Right)^; end;
+procedure lpeVariant_LTEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PUInt64(Right)^; end;
+procedure lpeVariant_LTEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PInt64(Right)^; end;
+procedure lpeVariant_LTEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PSingle(Right)^; end;
+procedure lpeVariant_LTEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PDouble(Right)^; end;
+procedure lpeVariant_LTEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PCurrency(Right)^; end;
+procedure lpeVariant_LTEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PExtended(Right)^; end;
+procedure lpeVariant_LTEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <= PVariant(Right)^; end;
+procedure lpeUInt8_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PUInt8(Right)^; end;
+procedure lpeUInt8_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PInt8(Right)^; end;
+procedure lpeUInt8_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PUInt16(Right)^; end;
+procedure lpeUInt8_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PInt16(Right)^; end;
+procedure lpeUInt8_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PUInt32(Right)^; end;
+procedure lpeUInt8_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PInt32(Right)^; end;
+procedure lpeUInt8_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PUInt64(Right)^; end;
+procedure lpeUInt8_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PInt64(Right)^; end;
+procedure lpeUInt8_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PSingle(Right)^; end;
+procedure lpeUInt8_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PDouble(Right)^; end;
+procedure lpeUInt8_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PCurrency(Right)^; end;
+procedure lpeUInt8_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PExtended(Right)^; end;
+procedure lpeUInt8_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt8(Left)^ <> PVariant(Right)^; end;
+procedure lpeInt8_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PUInt8(Right)^; end;
+procedure lpeInt8_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PInt8(Right)^; end;
+procedure lpeInt8_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PUInt16(Right)^; end;
+procedure lpeInt8_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PInt16(Right)^; end;
+procedure lpeInt8_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PUInt32(Right)^; end;
+procedure lpeInt8_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PInt32(Right)^; end;
+procedure lpeInt8_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PUInt64(Right)^; end;
+procedure lpeInt8_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PInt64(Right)^; end;
+procedure lpeInt8_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PSingle(Right)^; end;
+procedure lpeInt8_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PDouble(Right)^; end;
+procedure lpeInt8_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PCurrency(Right)^; end;
+procedure lpeInt8_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PExtended(Right)^; end;
+procedure lpeInt8_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt8(Left)^ <> PVariant(Right)^; end;
+procedure lpeUInt16_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PUInt8(Right)^; end;
+procedure lpeUInt16_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PInt8(Right)^; end;
+procedure lpeUInt16_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PUInt16(Right)^; end;
+procedure lpeUInt16_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PInt16(Right)^; end;
+procedure lpeUInt16_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PUInt32(Right)^; end;
+procedure lpeUInt16_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PInt32(Right)^; end;
+procedure lpeUInt16_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PUInt64(Right)^; end;
+procedure lpeUInt16_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PInt64(Right)^; end;
+procedure lpeUInt16_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PSingle(Right)^; end;
+procedure lpeUInt16_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PDouble(Right)^; end;
+procedure lpeUInt16_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PCurrency(Right)^; end;
+procedure lpeUInt16_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PExtended(Right)^; end;
+procedure lpeUInt16_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt16(Left)^ <> PVariant(Right)^; end;
+procedure lpeInt16_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PUInt8(Right)^; end;
+procedure lpeInt16_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PInt8(Right)^; end;
+procedure lpeInt16_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PUInt16(Right)^; end;
+procedure lpeInt16_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PInt16(Right)^; end;
+procedure lpeInt16_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PUInt32(Right)^; end;
+procedure lpeInt16_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PInt32(Right)^; end;
+procedure lpeInt16_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PUInt64(Right)^; end;
+procedure lpeInt16_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PInt64(Right)^; end;
+procedure lpeInt16_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PSingle(Right)^; end;
+procedure lpeInt16_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PDouble(Right)^; end;
+procedure lpeInt16_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PCurrency(Right)^; end;
+procedure lpeInt16_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PExtended(Right)^; end;
+procedure lpeInt16_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt16(Left)^ <> PVariant(Right)^; end;
+procedure lpeUInt32_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PUInt8(Right)^; end;
+procedure lpeUInt32_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PInt8(Right)^; end;
+procedure lpeUInt32_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PUInt16(Right)^; end;
+procedure lpeUInt32_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PInt16(Right)^; end;
+procedure lpeUInt32_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PUInt32(Right)^; end;
+procedure lpeUInt32_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PInt32(Right)^; end;
+procedure lpeUInt32_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PUInt64(Right)^; end;
+procedure lpeUInt32_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PInt64(Right)^; end;
+procedure lpeUInt32_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PSingle(Right)^; end;
+procedure lpeUInt32_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PDouble(Right)^; end;
+procedure lpeUInt32_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PCurrency(Right)^; end;
+procedure lpeUInt32_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PExtended(Right)^; end;
+procedure lpeUInt32_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt32(Left)^ <> PVariant(Right)^; end;
+procedure lpeInt32_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PUInt8(Right)^; end;
+procedure lpeInt32_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PInt8(Right)^; end;
+procedure lpeInt32_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PUInt16(Right)^; end;
+procedure lpeInt32_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PInt16(Right)^; end;
+procedure lpeInt32_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PUInt32(Right)^; end;
+procedure lpeInt32_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PInt32(Right)^; end;
+procedure lpeInt32_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PUInt64(Right)^; end;
+procedure lpeInt32_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PInt64(Right)^; end;
+procedure lpeInt32_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PSingle(Right)^; end;
+procedure lpeInt32_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PDouble(Right)^; end;
+procedure lpeInt32_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PCurrency(Right)^; end;
+procedure lpeInt32_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PExtended(Right)^; end;
+procedure lpeInt32_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt32(Left)^ <> PVariant(Right)^; end;
+procedure lpeUInt64_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PUInt8(Right)^; end;
+procedure lpeUInt64_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PInt8(Right)^; end;
+procedure lpeUInt64_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PUInt16(Right)^; end;
+procedure lpeUInt64_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PInt16(Right)^; end;
+procedure lpeUInt64_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PUInt32(Right)^; end;
+procedure lpeUInt64_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PInt32(Right)^; end;
+procedure lpeUInt64_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PUInt64(Right)^; end;
+procedure lpeUInt64_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PInt64(Right)^; end;
+procedure lpeUInt64_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PSingle(Right)^; end;
+procedure lpeUInt64_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PDouble(Right)^; end;
+procedure lpeUInt64_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PCurrency(Right)^; end;
+procedure lpeUInt64_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PExtended(Right)^; end;
+procedure lpeUInt64_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUInt64(Left)^ <> PVariant(Right)^; end;
+procedure lpeInt64_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PUInt8(Right)^; end;
+procedure lpeInt64_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PInt8(Right)^; end;
+procedure lpeInt64_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PUInt16(Right)^; end;
+procedure lpeInt64_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PInt16(Right)^; end;
+procedure lpeInt64_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PUInt32(Right)^; end;
+procedure lpeInt64_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PInt32(Right)^; end;
+procedure lpeInt64_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PUInt64(Right)^; end;
+procedure lpeInt64_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PInt64(Right)^; end;
+procedure lpeInt64_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PSingle(Right)^; end;
+procedure lpeInt64_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PDouble(Right)^; end;
+procedure lpeInt64_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PCurrency(Right)^; end;
+procedure lpeInt64_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PExtended(Right)^; end;
+procedure lpeInt64_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PInt64(Left)^ <> PVariant(Right)^; end;
+procedure lpeSingle_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PUInt8(Right)^; end;
+procedure lpeSingle_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PInt8(Right)^; end;
+procedure lpeSingle_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PUInt16(Right)^; end;
+procedure lpeSingle_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PInt16(Right)^; end;
+procedure lpeSingle_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PUInt32(Right)^; end;
+procedure lpeSingle_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PInt32(Right)^; end;
+procedure lpeSingle_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PUInt64(Right)^; end;
+procedure lpeSingle_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PInt64(Right)^; end;
+procedure lpeSingle_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PSingle(Right)^; end;
+procedure lpeSingle_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PDouble(Right)^; end;
+procedure lpeSingle_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PCurrency(Right)^; end;
+procedure lpeSingle_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PExtended(Right)^; end;
+procedure lpeSingle_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PSingle(Left)^ <> PVariant(Right)^; end;
+procedure lpeDouble_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PUInt8(Right)^; end;
+procedure lpeDouble_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PInt8(Right)^; end;
+procedure lpeDouble_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PUInt16(Right)^; end;
+procedure lpeDouble_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PInt16(Right)^; end;
+procedure lpeDouble_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PUInt32(Right)^; end;
+procedure lpeDouble_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PInt32(Right)^; end;
+procedure lpeDouble_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PUInt64(Right)^; end;
+procedure lpeDouble_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PInt64(Right)^; end;
+procedure lpeDouble_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PSingle(Right)^; end;
+procedure lpeDouble_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PDouble(Right)^; end;
+procedure lpeDouble_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PCurrency(Right)^; end;
+procedure lpeDouble_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PExtended(Right)^; end;
+procedure lpeDouble_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PDouble(Left)^ <> PVariant(Right)^; end;
+procedure lpeCurrency_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PUInt8(Right)^; end;
+procedure lpeCurrency_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PInt8(Right)^; end;
+procedure lpeCurrency_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PUInt16(Right)^; end;
+procedure lpeCurrency_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PInt16(Right)^; end;
+procedure lpeCurrency_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PUInt32(Right)^; end;
+procedure lpeCurrency_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PInt32(Right)^; end;
+procedure lpeCurrency_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PUInt64(Right)^; end;
+procedure lpeCurrency_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PInt64(Right)^; end;
+procedure lpeCurrency_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PSingle(Right)^; end;
+procedure lpeCurrency_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PDouble(Right)^; end;
+procedure lpeCurrency_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PCurrency(Right)^; end;
+procedure lpeCurrency_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PExtended(Right)^; end;
+procedure lpeCurrency_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PCurrency(Left)^ <> PVariant(Right)^; end;
+procedure lpeExtended_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PUInt8(Right)^; end;
+procedure lpeExtended_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PInt8(Right)^; end;
+procedure lpeExtended_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PUInt16(Right)^; end;
+procedure lpeExtended_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PInt16(Right)^; end;
+procedure lpeExtended_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PUInt32(Right)^; end;
+procedure lpeExtended_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PInt32(Right)^; end;
+procedure lpeExtended_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PUInt64(Right)^; end;
+procedure lpeExtended_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PInt64(Right)^; end;
+procedure lpeExtended_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PSingle(Right)^; end;
+procedure lpeExtended_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PDouble(Right)^; end;
+procedure lpeExtended_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PCurrency(Right)^; end;
+procedure lpeExtended_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PExtended(Right)^; end;
+procedure lpeExtended_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PExtended(Left)^ <> PVariant(Right)^; end;
+procedure lpeVariant_NEQ_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PUInt8(Right)^; end;
+procedure lpeVariant_NEQ_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PInt8(Right)^; end;
+procedure lpeVariant_NEQ_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PUInt16(Right)^; end;
+procedure lpeVariant_NEQ_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PInt16(Right)^; end;
+procedure lpeVariant_NEQ_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PUInt32(Right)^; end;
+procedure lpeVariant_NEQ_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PInt32(Right)^; end;
+procedure lpeVariant_NEQ_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PUInt64(Right)^; end;
+procedure lpeVariant_NEQ_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PInt64(Right)^; end;
+procedure lpeVariant_NEQ_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PSingle(Right)^; end;
+procedure lpeVariant_NEQ_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PDouble(Right)^; end;
+procedure lpeVariant_NEQ_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PCurrency(Right)^; end;
+procedure lpeVariant_NEQ_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PExtended(Right)^; end;
+procedure lpeVariant_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PVariant(Left)^ <> PVariant(Right)^; end;
+procedure lpeUInt8_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PUInt8(Left)^ and PUInt8(Right)^; end;
+procedure lpeUInt8_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PUInt8(Left)^ and PInt8(Right)^; end;
+procedure lpeUInt8_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := UInt16(PUInt8(Left)^) and UInt16(PUInt16(Right)^); end;
+procedure lpeUInt8_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := Int16(PUInt8(Left)^) and Int16(PInt16(Right)^); end;
+procedure lpeUInt8_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) and UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) and Int32(PInt32(Right)^); end;
+procedure lpeUInt8_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) and UInt64(PUInt64(Right)^); end;
+procedure lpeUInt8_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) and Int64(PInt64(Right)^); end;
+procedure lpeUInt8_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ and PVariant(Right)^; end;
+procedure lpeInt8_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PInt8(Left)^ and PUInt8(Right)^; end;
+procedure lpeInt8_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PInt8(Left)^ and PInt8(Right)^; end;
+procedure lpeInt8_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := UInt16(PInt8(Left)^) and UInt16(PUInt16(Right)^); end;
+procedure lpeInt8_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := Int16(PInt8(Left)^) and Int16(PInt16(Right)^); end;
+procedure lpeInt8_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PInt8(Left)^) and UInt32(PUInt32(Right)^); end;
+procedure lpeInt8_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) and Int32(PInt32(Right)^); end;
+procedure lpeInt8_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) and UInt64(PUInt64(Right)^); end;
+procedure lpeInt8_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) and Int64(PInt64(Right)^); end;
+procedure lpeInt8_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ and PVariant(Right)^; end;
+procedure lpeUInt16_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^ and PUInt8(Right)^; end;
+procedure lpeUInt16_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^ and PInt8(Right)^; end;
+procedure lpeUInt16_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^ and PUInt16(Right)^; end;
+procedure lpeUInt16_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^ and PInt16(Right)^; end;
+procedure lpeUInt16_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) and UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) and Int32(PInt32(Right)^); end;
+procedure lpeUInt16_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) and UInt64(PUInt64(Right)^); end;
+procedure lpeUInt16_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) and Int64(PInt64(Right)^); end;
+procedure lpeUInt16_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ and PVariant(Right)^; end;
+procedure lpeInt16_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt16(Left)^ and PUInt8(Right)^; end;
+procedure lpeInt16_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt16(Left)^ and PInt8(Right)^; end;
+procedure lpeInt16_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PInt16(Left)^ and PUInt16(Right)^; end;
+procedure lpeInt16_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt16(Left)^ and PInt16(Right)^; end;
+procedure lpeInt16_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PInt16(Left)^) and UInt32(PUInt32(Right)^); end;
+procedure lpeInt16_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) and Int32(PInt32(Right)^); end;
+procedure lpeInt16_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) and UInt64(PUInt64(Right)^); end;
+procedure lpeInt16_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) and Int64(PInt64(Right)^); end;
+procedure lpeInt16_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ and PVariant(Right)^; end;
+procedure lpeUInt32_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ and PUInt8(Right)^; end;
+procedure lpeUInt32_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ and PInt8(Right)^; end;
+procedure lpeUInt32_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ and PUInt16(Right)^; end;
+procedure lpeUInt32_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ and PInt16(Right)^; end;
+procedure lpeUInt32_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ and PUInt32(Right)^; end;
+procedure lpeUInt32_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ and PInt32(Right)^; end;
+procedure lpeUInt32_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) and UInt64(PUInt64(Right)^); end;
+procedure lpeUInt32_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) and Int64(PInt64(Right)^); end;
+procedure lpeUInt32_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ and PVariant(Right)^; end;
+procedure lpeInt32_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ and PUInt8(Right)^; end;
+procedure lpeInt32_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ and PInt8(Right)^; end;
+procedure lpeInt32_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ and PUInt16(Right)^; end;
+procedure lpeInt32_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ and PInt16(Right)^; end;
+procedure lpeInt32_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PInt32(Left)^ and PUInt32(Right)^; end;
+procedure lpeInt32_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ and PInt32(Right)^; end;
+procedure lpeInt32_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) and UInt64(PUInt64(Right)^); end;
+procedure lpeInt32_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) and Int64(PInt64(Right)^); end;
+procedure lpeInt32_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ and PVariant(Right)^; end;
+procedure lpeUInt64_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ and PUInt8(Right)^; end;
+procedure lpeUInt64_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ and PInt8(Right)^; end;
+procedure lpeUInt64_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ and PUInt16(Right)^; end;
+procedure lpeUInt64_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ and PInt16(Right)^; end;
+procedure lpeUInt64_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ and PUInt32(Right)^; end;
+procedure lpeUInt64_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ and PInt32(Right)^; end;
+procedure lpeUInt64_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ and PUInt64(Right)^; end;
+procedure lpeUInt64_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) and Int64(PInt64(Right)^); end;
+procedure lpeUInt64_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ and PVariant(Right)^; end;
+procedure lpeInt64_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ and PUInt8(Right)^; end;
+procedure lpeInt64_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ and PInt8(Right)^; end;
+procedure lpeInt64_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ and PUInt16(Right)^; end;
+procedure lpeInt64_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ and PInt16(Right)^; end;
+procedure lpeInt64_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ and PUInt32(Right)^; end;
+procedure lpeInt64_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ and PInt32(Right)^; end;
+procedure lpeInt64_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ and PUInt64(Right)^; end;
+procedure lpeInt64_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ and PInt64(Right)^; end;
+procedure lpeInt64_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ and PVariant(Right)^; end;
+procedure lpeVariant_AND_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PUInt8(Right)^; end;
+procedure lpeVariant_AND_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PInt8(Right)^; end;
+procedure lpeVariant_AND_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PUInt16(Right)^; end;
+procedure lpeVariant_AND_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PInt16(Right)^; end;
+procedure lpeVariant_AND_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PUInt32(Right)^; end;
+procedure lpeVariant_AND_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PInt32(Right)^; end;
+procedure lpeVariant_AND_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PUInt64(Right)^; end;
+procedure lpeVariant_AND_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PInt64(Right)^; end;
+procedure lpeVariant_AND_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ and PVariant(Right)^; end;
+procedure lpeUInt8_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PUInt8(Left)^; end;
+procedure lpeUInt8_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PInt8(Left)^; end;
+procedure lpeUInt8_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PUInt16(Left)^; end;
+procedure lpeUInt8_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PInt16(Left)^; end;
+procedure lpeUInt8_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PUInt32(Left)^; end;
+procedure lpeUInt8_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PInt32(Left)^; end;
+procedure lpeUInt8_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PUInt64(Left)^; end;
+procedure lpeUInt8_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PInt64(Left)^; end;
+procedure lpeUInt8_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PVariant(Left)^; end;
+procedure lpeInt8_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PUInt8(Left)^; end;
+procedure lpeInt8_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PInt8(Left)^; end;
+procedure lpeInt8_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PUInt16(Left)^; end;
+procedure lpeInt8_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PInt16(Left)^; end;
+procedure lpeInt8_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PUInt32(Left)^; end;
+procedure lpeInt8_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PInt32(Left)^; end;
+procedure lpeInt8_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PUInt64(Left)^; end;
+procedure lpeInt8_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PInt64(Left)^; end;
+procedure lpeInt8_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PVariant(Left)^; end;
+procedure lpeUInt16_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt8(Left)^; end;
+procedure lpeUInt16_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PInt8(Left)^; end;
+procedure lpeUInt16_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^; end;
+procedure lpeUInt16_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PInt16(Left)^; end;
+procedure lpeUInt16_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt32(Left)^; end;
+procedure lpeUInt16_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PInt32(Left)^; end;
+procedure lpeUInt16_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt64(Left)^; end;
+procedure lpeUInt16_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PInt64(Left)^; end;
+procedure lpeUInt16_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PVariant(Left)^; end;
+procedure lpeInt16_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PUInt8(Left)^; end;
+procedure lpeInt16_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt8(Left)^; end;
+procedure lpeInt16_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PUInt16(Left)^; end;
+procedure lpeInt16_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt16(Left)^; end;
+procedure lpeInt16_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PUInt32(Left)^; end;
+procedure lpeInt16_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt32(Left)^; end;
+procedure lpeInt16_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PUInt64(Left)^; end;
+procedure lpeInt16_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt64(Left)^; end;
+procedure lpeInt16_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PVariant(Left)^; end;
+procedure lpeUInt32_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt8(Left)^; end;
+procedure lpeUInt32_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PInt8(Left)^; end;
+procedure lpeUInt32_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt16(Left)^; end;
+procedure lpeUInt32_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PInt16(Left)^; end;
+procedure lpeUInt32_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^; end;
+procedure lpeUInt32_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PInt32(Left)^; end;
+procedure lpeUInt32_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt64(Left)^; end;
+procedure lpeUInt32_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PInt64(Left)^; end;
+procedure lpeUInt32_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PVariant(Left)^; end;
+procedure lpeInt32_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PUInt8(Left)^; end;
+procedure lpeInt32_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt8(Left)^; end;
+procedure lpeInt32_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PUInt16(Left)^; end;
+procedure lpeInt32_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt16(Left)^; end;
+procedure lpeInt32_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PUInt32(Left)^; end;
+procedure lpeInt32_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^; end;
+procedure lpeInt32_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PUInt64(Left)^; end;
+procedure lpeInt32_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt64(Left)^; end;
+procedure lpeInt32_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PVariant(Left)^; end;
+procedure lpeUInt64_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt8(Left)^; end;
+procedure lpeUInt64_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PInt8(Left)^; end;
+procedure lpeUInt64_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt16(Left)^; end;
+procedure lpeUInt64_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PInt16(Left)^; end;
+procedure lpeUInt64_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt32(Left)^; end;
+procedure lpeUInt64_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PInt32(Left)^; end;
+procedure lpeUInt64_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^; end;
+procedure lpeUInt64_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PInt64(Left)^; end;
+procedure lpeUInt64_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PVariant(Left)^; end;
+procedure lpeInt64_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PUInt8(Left)^; end;
+procedure lpeInt64_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt8(Left)^; end;
+procedure lpeInt64_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PUInt16(Left)^; end;
+procedure lpeInt64_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt16(Left)^; end;
+procedure lpeInt64_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PUInt32(Left)^; end;
+procedure lpeInt64_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt32(Left)^; end;
+procedure lpeInt64_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PUInt64(Left)^; end;
+procedure lpeInt64_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^; end;
+procedure lpeInt64_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PVariant(Left)^; end;
+procedure lpeSingle_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt8(Left)^; end;
+procedure lpeSingle_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt8(Left)^; end;
+procedure lpeSingle_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt16(Left)^; end;
+procedure lpeSingle_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt16(Left)^; end;
+procedure lpeSingle_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt32(Left)^; end;
+procedure lpeSingle_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt32(Left)^; end;
+procedure lpeSingle_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt64(Left)^; end;
+procedure lpeSingle_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt64(Left)^; end;
+procedure lpeSingle_ASGN_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^; end;
+procedure lpeSingle_ASGN_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PDouble(Left)^; end;
+procedure lpeSingle_ASGN_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PCurrency(Left)^; end;
+procedure lpeSingle_ASGN_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PExtended(Left)^; end;
+procedure lpeSingle_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PVariant(Left)^; end;
+procedure lpeDouble_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt8(Left)^; end;
+procedure lpeDouble_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt8(Left)^; end;
+procedure lpeDouble_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt16(Left)^; end;
+procedure lpeDouble_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt16(Left)^; end;
+procedure lpeDouble_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt32(Left)^; end;
+procedure lpeDouble_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt32(Left)^; end;
+procedure lpeDouble_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt64(Left)^; end;
+procedure lpeDouble_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt64(Left)^; end;
+procedure lpeDouble_ASGN_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PSingle(Left)^; end;
+procedure lpeDouble_ASGN_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^; end;
+procedure lpeDouble_ASGN_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PCurrency(Left)^; end;
+procedure lpeDouble_ASGN_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PExtended(Left)^; end;
+procedure lpeDouble_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PVariant(Left)^; end;
+procedure lpeCurrency_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt8(Left)^; end;
+procedure lpeCurrency_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt8(Left)^; end;
+procedure lpeCurrency_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt16(Left)^; end;
+procedure lpeCurrency_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt16(Left)^; end;
+procedure lpeCurrency_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt32(Left)^; end;
+procedure lpeCurrency_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt32(Left)^; end;
+procedure lpeCurrency_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt64(Left)^; end;
+procedure lpeCurrency_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt64(Left)^; end;
+procedure lpeCurrency_ASGN_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PSingle(Left)^; end;
+procedure lpeCurrency_ASGN_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PDouble(Left)^; end;
+procedure lpeCurrency_ASGN_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^; end;
+procedure lpeCurrency_ASGN_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PExtended(Left)^; end;
+procedure lpeCurrency_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PVariant(Left)^; end;
+procedure lpeExtended_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^; end;
+procedure lpeExtended_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^; end;
+procedure lpeExtended_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^; end;
+procedure lpeExtended_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^; end;
+procedure lpeExtended_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^; end;
+procedure lpeExtended_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^; end;
+procedure lpeExtended_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^; end;
+procedure lpeExtended_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^; end;
+procedure lpeExtended_ASGN_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PSingle(Left)^; end;
+procedure lpeExtended_ASGN_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PDouble(Left)^; end;
+procedure lpeExtended_ASGN_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PCurrency(Left)^; end;
+procedure lpeExtended_ASGN_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^; end;
+procedure lpeExtended_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PVariant(Left)^; end;
+procedure lpeVariant_ASGN_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^; end;
+procedure lpeVariant_ASGN_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^; end;
+procedure lpeVariant_ASGN_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^; end;
+procedure lpeVariant_ASGN_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^; end;
+procedure lpeVariant_ASGN_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^; end;
+procedure lpeVariant_ASGN_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^; end;
+procedure lpeVariant_ASGN_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^; end;
+procedure lpeVariant_ASGN_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^; end;
+procedure lpeVariant_ASGN_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PSingle(Left)^; end;
+procedure lpeVariant_ASGN_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PDouble(Left)^; end;
+procedure lpeVariant_ASGN_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PCurrency(Left)^; end;
+procedure lpeVariant_ASGN_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PExtended(Left)^; end;
+procedure lpeVariant_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^; end;
+procedure lpeUInt8_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PUInt8(Right)^); end;
+procedure lpeUInt8_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PInt8(Right)^); end;
+procedure lpeUInt8_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PUInt16(Right)^); end;
+procedure lpeUInt8_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PInt16(Right)^); end;
+procedure lpeUInt8_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) div UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) div Int32(PInt32(Right)^); end;
+procedure lpeUInt8_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) div UInt64(PUInt64(Right)^); end;
+procedure lpeUInt8_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) div Int64(PInt64(Right)^); end;
+procedure lpeUInt8_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ div PVariant(Right)^; end;
+procedure lpeInt8_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PUInt8(Right)^); end;
+procedure lpeInt8_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PInt8(Right)^); end;
+procedure lpeInt8_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PUInt16(Right)^); end;
+procedure lpeInt8_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PInt16(Right)^); end;
+procedure lpeInt8_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) div Int64(PUInt32(Right)^); end;
+procedure lpeInt8_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) div Int32(PInt32(Right)^); end;
+procedure lpeInt8_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) div Int64(PUInt64(Right)^); end;
+procedure lpeInt8_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) div Int64(PInt64(Right)^); end;
+procedure lpeInt8_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ div PVariant(Right)^; end;
+procedure lpeUInt16_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PUInt8(Right)^); end;
+procedure lpeUInt16_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PInt8(Right)^); end;
+procedure lpeUInt16_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PUInt16(Right)^); end;
+procedure lpeUInt16_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PInt16(Right)^); end;
+procedure lpeUInt16_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) div UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) div Int32(PInt32(Right)^); end;
+procedure lpeUInt16_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) div UInt64(PUInt64(Right)^); end;
+procedure lpeUInt16_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) div Int64(PInt64(Right)^); end;
+procedure lpeUInt16_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ div PVariant(Right)^; end;
+procedure lpeInt16_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PUInt8(Right)^); end;
+procedure lpeInt16_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PInt8(Right)^); end;
+procedure lpeInt16_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PUInt16(Right)^); end;
+procedure lpeInt16_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PInt16(Right)^); end;
+procedure lpeInt16_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) div Int64(PUInt32(Right)^); end;
+procedure lpeInt16_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) div Int32(PInt32(Right)^); end;
+procedure lpeInt16_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) div Int64(PUInt64(Right)^); end;
+procedure lpeInt16_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) div Int64(PInt64(Right)^); end;
+procedure lpeInt16_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ div PVariant(Right)^; end;
+procedure lpeUInt32_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ div PUInt8(Right)^; end;
+procedure lpeUInt32_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) div Int64(PInt8(Right)^); end;
+procedure lpeUInt32_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ div PUInt16(Right)^; end;
+procedure lpeUInt32_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) div Int64(PInt16(Right)^); end;
+procedure lpeUInt32_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ div PUInt32(Right)^; end;
+procedure lpeUInt32_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) div Int64(PInt32(Right)^); end;
+procedure lpeUInt32_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) div UInt64(PUInt64(Right)^); end;
+procedure lpeUInt32_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) div Int64(PInt64(Right)^); end;
+procedure lpeUInt32_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ div PVariant(Right)^; end;
+procedure lpeInt32_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ div PUInt8(Right)^; end;
+procedure lpeInt32_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ div PInt8(Right)^; end;
+procedure lpeInt32_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ div PUInt16(Right)^; end;
+procedure lpeInt32_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ div PInt16(Right)^; end;
+procedure lpeInt32_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) div Int64(PUInt32(Right)^); end;
+procedure lpeInt32_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ div PInt32(Right)^; end;
+procedure lpeInt32_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) div Int64(PUInt64(Right)^); end;
+procedure lpeInt32_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) div Int64(PInt64(Right)^); end;
+procedure lpeInt32_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ div PVariant(Right)^; end;
+procedure lpeUInt64_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ div PUInt8(Right)^; end;
+procedure lpeUInt64_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) div Int64(PInt8(Right)^); end;
+procedure lpeUInt64_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ div PUInt16(Right)^; end;
+procedure lpeUInt64_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) div Int64(PInt16(Right)^); end;
+procedure lpeUInt64_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ div PUInt32(Right)^; end;
+procedure lpeUInt64_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) div Int64(PInt32(Right)^); end;
+procedure lpeUInt64_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ div PUInt64(Right)^; end;
+procedure lpeUInt64_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) div Int64(PInt64(Right)^); end;
+procedure lpeUInt64_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ div PVariant(Right)^; end;
+procedure lpeInt64_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ div PUInt8(Right)^; end;
+procedure lpeInt64_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ div PInt8(Right)^; end;
+procedure lpeInt64_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ div PUInt16(Right)^; end;
+procedure lpeInt64_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ div PInt16(Right)^; end;
+procedure lpeInt64_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ div PUInt32(Right)^; end;
+procedure lpeInt64_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ div PInt32(Right)^; end;
+procedure lpeInt64_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ div PUInt64(Right)^; end;
+procedure lpeInt64_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ div PInt64(Right)^; end;
+procedure lpeInt64_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ div PVariant(Right)^; end;
+procedure lpeVariant_IDIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PUInt8(Right)^; end;
+procedure lpeVariant_IDIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PInt8(Right)^; end;
+procedure lpeVariant_IDIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PUInt16(Right)^; end;
+procedure lpeVariant_IDIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PInt16(Right)^; end;
+procedure lpeVariant_IDIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PUInt32(Right)^; end;
+procedure lpeVariant_IDIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PInt32(Right)^; end;
+procedure lpeVariant_IDIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PUInt64(Right)^; end;
+procedure lpeVariant_IDIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PInt64(Right)^; end;
+procedure lpeVariant_IDIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ div PVariant(Right)^; end;
+procedure lpeUInt8_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PUInt8(Right)^; end;
+procedure lpeUInt8_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PInt8(Right)^; end;
+procedure lpeUInt8_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PUInt16(Right)^; end;
+procedure lpeUInt8_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PInt16(Right)^; end;
+procedure lpeUInt8_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PUInt32(Right)^; end;
+procedure lpeUInt8_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PInt32(Right)^; end;
+procedure lpeUInt8_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PUInt64(Right)^; end;
+procedure lpeUInt8_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PInt64(Right)^; end;
+procedure lpeUInt8_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt8(Left)^ / PSingle(Right)^; end;
+procedure lpeUInt8_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt8(Left)^ / PDouble(Right)^; end;
+procedure lpeUInt8_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt8(Left)^ / PCurrency(Right)^; end;
+procedure lpeUInt8_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ / PExtended(Right)^; end;
+procedure lpeUInt8_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ / PVariant(Right)^; end;
+procedure lpeInt8_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PUInt8(Right)^; end;
+procedure lpeInt8_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PInt8(Right)^; end;
+procedure lpeInt8_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PUInt16(Right)^; end;
+procedure lpeInt8_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PInt16(Right)^; end;
+procedure lpeInt8_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PUInt32(Right)^; end;
+procedure lpeInt8_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PInt32(Right)^; end;
+procedure lpeInt8_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PUInt64(Right)^; end;
+procedure lpeInt8_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PInt64(Right)^; end;
+procedure lpeInt8_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt8(Left)^ / PSingle(Right)^; end;
+procedure lpeInt8_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt8(Left)^ / PDouble(Right)^; end;
+procedure lpeInt8_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt8(Left)^ / PCurrency(Right)^; end;
+procedure lpeInt8_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ / PExtended(Right)^; end;
+procedure lpeInt8_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ / PVariant(Right)^; end;
+procedure lpeUInt16_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PUInt8(Right)^; end;
+procedure lpeUInt16_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PInt8(Right)^; end;
+procedure lpeUInt16_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PUInt16(Right)^; end;
+procedure lpeUInt16_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PInt16(Right)^; end;
+procedure lpeUInt16_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PUInt32(Right)^; end;
+procedure lpeUInt16_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PInt32(Right)^; end;
+procedure lpeUInt16_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PUInt64(Right)^; end;
+procedure lpeUInt16_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PInt64(Right)^; end;
+procedure lpeUInt16_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt16(Left)^ / PSingle(Right)^; end;
+procedure lpeUInt16_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt16(Left)^ / PDouble(Right)^; end;
+procedure lpeUInt16_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt16(Left)^ / PCurrency(Right)^; end;
+procedure lpeUInt16_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ / PExtended(Right)^; end;
+procedure lpeUInt16_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ / PVariant(Right)^; end;
+procedure lpeInt16_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PUInt8(Right)^; end;
+procedure lpeInt16_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PInt8(Right)^; end;
+procedure lpeInt16_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PUInt16(Right)^; end;
+procedure lpeInt16_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PInt16(Right)^; end;
+procedure lpeInt16_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PUInt32(Right)^; end;
+procedure lpeInt16_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PInt32(Right)^; end;
+procedure lpeInt16_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PUInt64(Right)^; end;
+procedure lpeInt16_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PInt64(Right)^; end;
+procedure lpeInt16_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt16(Left)^ / PSingle(Right)^; end;
+procedure lpeInt16_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt16(Left)^ / PDouble(Right)^; end;
+procedure lpeInt16_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt16(Left)^ / PCurrency(Right)^; end;
+procedure lpeInt16_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ / PExtended(Right)^; end;
+procedure lpeInt16_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ / PVariant(Right)^; end;
+procedure lpeUInt32_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PUInt8(Right)^; end;
+procedure lpeUInt32_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PInt8(Right)^; end;
+procedure lpeUInt32_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PUInt16(Right)^; end;
+procedure lpeUInt32_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PInt16(Right)^; end;
+procedure lpeUInt32_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PUInt32(Right)^; end;
+procedure lpeUInt32_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PInt32(Right)^; end;
+procedure lpeUInt32_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PUInt64(Right)^; end;
+procedure lpeUInt32_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PInt64(Right)^; end;
+procedure lpeUInt32_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt32(Left)^ / PSingle(Right)^; end;
+procedure lpeUInt32_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt32(Left)^ / PDouble(Right)^; end;
+procedure lpeUInt32_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt32(Left)^ / PCurrency(Right)^; end;
+procedure lpeUInt32_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ / PExtended(Right)^; end;
+procedure lpeUInt32_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ / PVariant(Right)^; end;
+procedure lpeInt32_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PUInt8(Right)^; end;
+procedure lpeInt32_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PInt8(Right)^; end;
+procedure lpeInt32_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PUInt16(Right)^; end;
+procedure lpeInt32_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PInt16(Right)^; end;
+procedure lpeInt32_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PUInt32(Right)^; end;
+procedure lpeInt32_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PInt32(Right)^; end;
+procedure lpeInt32_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PUInt64(Right)^; end;
+procedure lpeInt32_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PInt64(Right)^; end;
+procedure lpeInt32_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt32(Left)^ / PSingle(Right)^; end;
+procedure lpeInt32_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt32(Left)^ / PDouble(Right)^; end;
+procedure lpeInt32_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt32(Left)^ / PCurrency(Right)^; end;
+procedure lpeInt32_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ / PExtended(Right)^; end;
+procedure lpeInt32_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ / PVariant(Right)^; end;
+procedure lpeUInt64_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PUInt8(Right)^; end;
+procedure lpeUInt64_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PInt8(Right)^; end;
+procedure lpeUInt64_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PUInt16(Right)^; end;
+procedure lpeUInt64_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PInt16(Right)^; end;
+procedure lpeUInt64_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PUInt32(Right)^; end;
+procedure lpeUInt64_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PInt32(Right)^; end;
+procedure lpeUInt64_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PUInt64(Right)^; end;
+procedure lpeUInt64_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PInt64(Right)^; end;
+procedure lpeUInt64_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt64(Left)^ / PSingle(Right)^; end;
+procedure lpeUInt64_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt64(Left)^ / PDouble(Right)^; end;
+procedure lpeUInt64_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt64(Left)^ / PCurrency(Right)^; end;
+procedure lpeUInt64_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ / PExtended(Right)^; end;
+procedure lpeUInt64_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ / PVariant(Right)^; end;
+procedure lpeInt64_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PUInt8(Right)^; end;
+procedure lpeInt64_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PInt8(Right)^; end;
+procedure lpeInt64_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PUInt16(Right)^; end;
+procedure lpeInt64_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PInt16(Right)^; end;
+procedure lpeInt64_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PUInt32(Right)^; end;
+procedure lpeInt64_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PInt32(Right)^; end;
+procedure lpeInt64_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PUInt64(Right)^; end;
+procedure lpeInt64_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PInt64(Right)^; end;
+procedure lpeInt64_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt64(Left)^ / PSingle(Right)^; end;
+procedure lpeInt64_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt64(Left)^ / PDouble(Right)^; end;
+procedure lpeInt64_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt64(Left)^ / PCurrency(Right)^; end;
+procedure lpeInt64_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ / PExtended(Right)^; end;
+procedure lpeInt64_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ / PVariant(Right)^; end;
+procedure lpeSingle_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PUInt8(Right)^; end;
+procedure lpeSingle_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PInt8(Right)^; end;
+procedure lpeSingle_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PUInt16(Right)^; end;
+procedure lpeSingle_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PInt16(Right)^; end;
+procedure lpeSingle_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PUInt32(Right)^; end;
+procedure lpeSingle_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PInt32(Right)^; end;
+procedure lpeSingle_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PUInt64(Right)^; end;
+procedure lpeSingle_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PInt64(Right)^; end;
+procedure lpeSingle_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ / PSingle(Right)^; end;
+procedure lpeSingle_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PSingle(Left)^ / PDouble(Right)^; end;
+procedure lpeSingle_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PSingle(Left)^ / PCurrency(Right)^; end;
+procedure lpeSingle_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PSingle(Left)^ / PExtended(Right)^; end;
+procedure lpeSingle_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PSingle(Left)^ / PVariant(Right)^; end;
+procedure lpeDouble_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PUInt8(Right)^; end;
+procedure lpeDouble_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PInt8(Right)^; end;
+procedure lpeDouble_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PUInt16(Right)^; end;
+procedure lpeDouble_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PInt16(Right)^; end;
+procedure lpeDouble_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PUInt32(Right)^; end;
+procedure lpeDouble_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PInt32(Right)^; end;
+procedure lpeDouble_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PUInt64(Right)^; end;
+procedure lpeDouble_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PInt64(Right)^; end;
+procedure lpeDouble_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PSingle(Right)^; end;
+procedure lpeDouble_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ / PDouble(Right)^; end;
+procedure lpeDouble_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PDouble(Left)^ / PCurrency(Right)^; end;
+procedure lpeDouble_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PDouble(Left)^ / PExtended(Right)^; end;
+procedure lpeDouble_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PDouble(Left)^ / PVariant(Right)^; end;
+procedure lpeCurrency_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PUInt8(Right)^; end;
+procedure lpeCurrency_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PInt8(Right)^; end;
+procedure lpeCurrency_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PUInt16(Right)^; end;
+procedure lpeCurrency_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PInt16(Right)^; end;
+procedure lpeCurrency_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PUInt32(Right)^; end;
+procedure lpeCurrency_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PInt32(Right)^; end;
+procedure lpeCurrency_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PUInt64(Right)^; end;
+procedure lpeCurrency_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PInt64(Right)^; end;
+procedure lpeCurrency_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PSingle(Right)^; end;
+procedure lpeCurrency_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PDouble(Right)^; end;
+procedure lpeCurrency_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PCurrency(Right)^; end;
+procedure lpeCurrency_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ / PExtended(Right)^; end;
+procedure lpeCurrency_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PCurrency(Left)^ / PVariant(Right)^; end;
+procedure lpeExtended_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PUInt8(Right)^; end;
+procedure lpeExtended_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PInt8(Right)^; end;
+procedure lpeExtended_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PUInt16(Right)^; end;
+procedure lpeExtended_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PInt16(Right)^; end;
+procedure lpeExtended_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PUInt32(Right)^; end;
+procedure lpeExtended_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PInt32(Right)^; end;
+procedure lpeExtended_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PUInt64(Right)^; end;
+procedure lpeExtended_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PInt64(Right)^; end;
+procedure lpeExtended_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PSingle(Right)^; end;
+procedure lpeExtended_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PDouble(Right)^; end;
+procedure lpeExtended_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PExtended(Left)^ / PCurrency(Right)^; end;
+procedure lpeExtended_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ / PExtended(Right)^; end;
+procedure lpeExtended_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PExtended(Left)^ / PVariant(Right)^; end;
+procedure lpeVariant_DIV_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PUInt8(Right)^; end;
+procedure lpeVariant_DIV_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PInt8(Right)^; end;
+procedure lpeVariant_DIV_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PUInt16(Right)^; end;
+procedure lpeVariant_DIV_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PInt16(Right)^; end;
+procedure lpeVariant_DIV_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PUInt32(Right)^; end;
+procedure lpeVariant_DIV_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PInt32(Right)^; end;
+procedure lpeVariant_DIV_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PUInt64(Right)^; end;
+procedure lpeVariant_DIV_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PInt64(Right)^; end;
+procedure lpeVariant_DIV_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PSingle(Right)^; end;
+procedure lpeVariant_DIV_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PDouble(Right)^; end;
+procedure lpeVariant_DIV_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PCurrency(Right)^; end;
+procedure lpeVariant_DIV_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PExtended(Right)^; end;
+procedure lpeVariant_DIV_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ / PVariant(Right)^; end;
+procedure lpeUInt8_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PUInt8(Right)^); end;
+procedure lpeUInt8_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PInt8(Right)^); end;
+procedure lpeUInt8_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PUInt16(Right)^); end;
+procedure lpeUInt8_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PInt16(Right)^); end;
+procedure lpeUInt8_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) - Int64(PUInt32(Right)^); end;
+procedure lpeUInt8_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) - Int32(PInt32(Right)^); end;
+procedure lpeUInt8_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) - UInt64(PUInt64(Right)^); end;
+procedure lpeUInt8_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) - Int64(PInt64(Right)^); end;
+procedure lpeUInt8_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt8(Left)^ - PSingle(Right)^; end;
+procedure lpeUInt8_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt8(Left)^ - PDouble(Right)^; end;
+procedure lpeUInt8_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt8(Left)^ - PCurrency(Right)^; end;
+procedure lpeUInt8_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ - PExtended(Right)^; end;
+procedure lpeUInt8_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ - PVariant(Right)^; end;
+procedure lpeInt8_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PUInt8(Right)^); end;
+procedure lpeInt8_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PInt8(Right)^); end;
+procedure lpeInt8_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PUInt16(Right)^); end;
+procedure lpeInt8_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PInt16(Right)^); end;
+procedure lpeInt8_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) - Int64(PUInt32(Right)^); end;
+procedure lpeInt8_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) - Int32(PInt32(Right)^); end;
+procedure lpeInt8_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) - UInt64(PUInt64(Right)^); end;
+procedure lpeInt8_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) - Int64(PInt64(Right)^); end;
+procedure lpeInt8_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt8(Left)^ - PSingle(Right)^; end;
+procedure lpeInt8_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt8(Left)^ - PDouble(Right)^; end;
+procedure lpeInt8_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt8(Left)^ - PCurrency(Right)^; end;
+procedure lpeInt8_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ - PExtended(Right)^; end;
+procedure lpeInt8_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ - PVariant(Right)^; end;
+procedure lpeUInt16_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PUInt8(Right)^); end;
+procedure lpeUInt16_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PInt8(Right)^); end;
+procedure lpeUInt16_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PUInt16(Right)^); end;
+procedure lpeUInt16_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PInt16(Right)^); end;
+procedure lpeUInt16_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) - Int64(PUInt32(Right)^); end;
+procedure lpeUInt16_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) - Int32(PInt32(Right)^); end;
+procedure lpeUInt16_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) - UInt64(PUInt64(Right)^); end;
+procedure lpeUInt16_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) - Int64(PInt64(Right)^); end;
+procedure lpeUInt16_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt16(Left)^ - PSingle(Right)^; end;
+procedure lpeUInt16_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt16(Left)^ - PDouble(Right)^; end;
+procedure lpeUInt16_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt16(Left)^ - PCurrency(Right)^; end;
+procedure lpeUInt16_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ - PExtended(Right)^; end;
+procedure lpeUInt16_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ - PVariant(Right)^; end;
+procedure lpeInt16_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PUInt8(Right)^); end;
+procedure lpeInt16_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PInt8(Right)^); end;
+procedure lpeInt16_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PUInt16(Right)^); end;
+procedure lpeInt16_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PInt16(Right)^); end;
+procedure lpeInt16_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) - Int64(PUInt32(Right)^); end;
+procedure lpeInt16_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) - Int32(PInt32(Right)^); end;
+procedure lpeInt16_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) - UInt64(PUInt64(Right)^); end;
+procedure lpeInt16_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) - Int64(PInt64(Right)^); end;
+procedure lpeInt16_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt16(Left)^ - PSingle(Right)^; end;
+procedure lpeInt16_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt16(Left)^ - PDouble(Right)^; end;
+procedure lpeInt16_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt16(Left)^ - PCurrency(Right)^; end;
+procedure lpeInt16_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ - PExtended(Right)^; end;
+procedure lpeInt16_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ - PVariant(Right)^; end;
+procedure lpeUInt32_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PUInt8(Right)^); end;
+procedure lpeUInt32_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PInt8(Right)^); end;
+procedure lpeUInt32_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PUInt16(Right)^); end;
+procedure lpeUInt32_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PInt16(Right)^); end;
+procedure lpeUInt32_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PUInt32(Right)^); end;
+procedure lpeUInt32_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PInt32(Right)^); end;
+procedure lpeUInt32_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) - UInt64(PUInt64(Right)^); end;
+procedure lpeUInt32_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) - Int64(PInt64(Right)^); end;
+procedure lpeUInt32_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt32(Left)^ - PSingle(Right)^; end;
+procedure lpeUInt32_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt32(Left)^ - PDouble(Right)^; end;
+procedure lpeUInt32_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt32(Left)^ - PCurrency(Right)^; end;
+procedure lpeUInt32_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ - PExtended(Right)^; end;
+procedure lpeUInt32_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ - PVariant(Right)^; end;
+procedure lpeInt32_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ - PUInt8(Right)^; end;
+procedure lpeInt32_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ - PInt8(Right)^; end;
+procedure lpeInt32_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ - PUInt16(Right)^; end;
+procedure lpeInt32_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ - PInt16(Right)^; end;
+procedure lpeInt32_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) - Int64(PUInt32(Right)^); end;
+procedure lpeInt32_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ - PInt32(Right)^; end;
+procedure lpeInt32_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) - UInt64(PUInt64(Right)^); end;
+procedure lpeInt32_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) - Int64(PInt64(Right)^); end;
+procedure lpeInt32_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt32(Left)^ - PSingle(Right)^; end;
+procedure lpeInt32_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt32(Left)^ - PDouble(Right)^; end;
+procedure lpeInt32_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt32(Left)^ - PCurrency(Right)^; end;
+procedure lpeInt32_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ - PExtended(Right)^; end;
+procedure lpeInt32_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ - PVariant(Right)^; end;
+procedure lpeUInt64_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ - PUInt8(Right)^; end;
+procedure lpeUInt64_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ - PInt8(Right)^; end;
+procedure lpeUInt64_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ - PUInt16(Right)^; end;
+procedure lpeUInt64_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ - PInt16(Right)^; end;
+procedure lpeUInt64_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ - PUInt32(Right)^; end;
+procedure lpeUInt64_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ - PInt32(Right)^; end;
+procedure lpeUInt64_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ - PUInt64(Right)^; end;
+procedure lpeUInt64_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) - Int64(PInt64(Right)^); end;
+procedure lpeUInt64_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt64(Left)^ - PSingle(Right)^; end;
+procedure lpeUInt64_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt64(Left)^ - PDouble(Right)^; end;
+procedure lpeUInt64_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt64(Left)^ - PCurrency(Right)^; end;
+procedure lpeUInt64_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ - PExtended(Right)^; end;
+procedure lpeUInt64_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ - PVariant(Right)^; end;
+procedure lpeInt64_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ - PUInt8(Right)^; end;
+procedure lpeInt64_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ - PInt8(Right)^; end;
+procedure lpeInt64_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ - PUInt16(Right)^; end;
+procedure lpeInt64_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ - PInt16(Right)^; end;
+procedure lpeInt64_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ - PUInt32(Right)^; end;
+procedure lpeInt64_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ - PInt32(Right)^; end;
+procedure lpeInt64_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ - PUInt64(Right)^; end;
+procedure lpeInt64_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ - PInt64(Right)^; end;
+procedure lpeInt64_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt64(Left)^ - PSingle(Right)^; end;
+procedure lpeInt64_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt64(Left)^ - PDouble(Right)^; end;
+procedure lpeInt64_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt64(Left)^ - PCurrency(Right)^; end;
+procedure lpeInt64_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ - PExtended(Right)^; end;
+procedure lpeInt64_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ - PVariant(Right)^; end;
+procedure lpeSingle_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PUInt8(Right)^; end;
+procedure lpeSingle_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PInt8(Right)^; end;
+procedure lpeSingle_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PUInt16(Right)^; end;
+procedure lpeSingle_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PInt16(Right)^; end;
+procedure lpeSingle_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PUInt32(Right)^; end;
+procedure lpeSingle_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PInt32(Right)^; end;
+procedure lpeSingle_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PUInt64(Right)^; end;
+procedure lpeSingle_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PInt64(Right)^; end;
+procedure lpeSingle_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ - PSingle(Right)^; end;
+procedure lpeSingle_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PSingle(Left)^ - PDouble(Right)^; end;
+procedure lpeSingle_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PSingle(Left)^ - PCurrency(Right)^; end;
+procedure lpeSingle_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PSingle(Left)^ - PExtended(Right)^; end;
+procedure lpeSingle_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PSingle(Left)^ - PVariant(Right)^; end;
+procedure lpeDouble_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PUInt8(Right)^; end;
+procedure lpeDouble_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PInt8(Right)^; end;
+procedure lpeDouble_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PUInt16(Right)^; end;
+procedure lpeDouble_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PInt16(Right)^; end;
+procedure lpeDouble_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PUInt32(Right)^; end;
+procedure lpeDouble_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PInt32(Right)^; end;
+procedure lpeDouble_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PUInt64(Right)^; end;
+procedure lpeDouble_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PInt64(Right)^; end;
+procedure lpeDouble_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PSingle(Right)^; end;
+procedure lpeDouble_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ - PDouble(Right)^; end;
+procedure lpeDouble_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PDouble(Left)^ - PCurrency(Right)^; end;
+procedure lpeDouble_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PDouble(Left)^ - PExtended(Right)^; end;
+procedure lpeDouble_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PDouble(Left)^ - PVariant(Right)^; end;
+procedure lpeCurrency_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PUInt8(Right)^; end;
+procedure lpeCurrency_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PInt8(Right)^; end;
+procedure lpeCurrency_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PUInt16(Right)^; end;
+procedure lpeCurrency_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PInt16(Right)^; end;
+procedure lpeCurrency_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PUInt32(Right)^; end;
+procedure lpeCurrency_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PInt32(Right)^; end;
+procedure lpeCurrency_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PUInt64(Right)^; end;
+procedure lpeCurrency_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PInt64(Right)^; end;
+procedure lpeCurrency_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PSingle(Right)^; end;
+procedure lpeCurrency_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PDouble(Right)^; end;
+procedure lpeCurrency_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PCurrency(Right)^; end;
+procedure lpeCurrency_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ - PExtended(Right)^; end;
+procedure lpeCurrency_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PCurrency(Left)^ - PVariant(Right)^; end;
+procedure lpeExtended_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PUInt8(Right)^; end;
+procedure lpeExtended_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PInt8(Right)^; end;
+procedure lpeExtended_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PUInt16(Right)^; end;
+procedure lpeExtended_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PInt16(Right)^; end;
+procedure lpeExtended_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PUInt32(Right)^; end;
+procedure lpeExtended_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PInt32(Right)^; end;
+procedure lpeExtended_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PUInt64(Right)^; end;
+procedure lpeExtended_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PInt64(Right)^; end;
+procedure lpeExtended_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PSingle(Right)^; end;
+procedure lpeExtended_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PDouble(Right)^; end;
+procedure lpeExtended_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PExtended(Left)^ - PCurrency(Right)^; end;
+procedure lpeExtended_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ - PExtended(Right)^; end;
+procedure lpeExtended_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PExtended(Left)^ - PVariant(Right)^; end;
+procedure lpeVariant_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PUInt8(Right)^; end;
+procedure lpeVariant_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PInt8(Right)^; end;
+procedure lpeVariant_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PUInt16(Right)^; end;
+procedure lpeVariant_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PInt16(Right)^; end;
+procedure lpeVariant_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PUInt32(Right)^; end;
+procedure lpeVariant_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PInt32(Right)^; end;
+procedure lpeVariant_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PUInt64(Right)^; end;
+procedure lpeVariant_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PInt64(Right)^; end;
+procedure lpeVariant_SUB_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PSingle(Right)^; end;
+procedure lpeVariant_SUB_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PDouble(Right)^; end;
+procedure lpeVariant_SUB_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PCurrency(Right)^; end;
+procedure lpeVariant_SUB_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PExtended(Right)^; end;
+procedure lpeVariant_SUB_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ - PVariant(Right)^; end;
+procedure lpeUInt8_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PUInt8(Right)^); end;
+procedure lpeUInt8_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PInt8(Right)^); end;
+procedure lpeUInt8_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PUInt16(Right)^); end;
+procedure lpeUInt8_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PInt16(Right)^); end;
+procedure lpeUInt8_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) mod UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) mod Int32(PInt32(Right)^); end;
+procedure lpeUInt8_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) mod UInt64(PUInt64(Right)^); end;
+procedure lpeUInt8_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) mod Int64(PInt64(Right)^); end;
+procedure lpeUInt8_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ mod PVariant(Right)^; end;
+procedure lpeInt8_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PUInt8(Right)^); end;
+procedure lpeInt8_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PInt8(Right)^); end;
+procedure lpeInt8_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PUInt16(Right)^); end;
+procedure lpeInt8_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PInt16(Right)^); end;
+procedure lpeInt8_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) mod Int64(PUInt32(Right)^); end;
+procedure lpeInt8_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) mod Int32(PInt32(Right)^); end;
+procedure lpeInt8_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) mod Int64(PUInt64(Right)^); end;
+procedure lpeInt8_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) mod Int64(PInt64(Right)^); end;
+procedure lpeInt8_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ mod PVariant(Right)^; end;
+procedure lpeUInt16_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PUInt8(Right)^); end;
+procedure lpeUInt16_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PInt8(Right)^); end;
+procedure lpeUInt16_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PUInt16(Right)^); end;
+procedure lpeUInt16_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PInt16(Right)^); end;
+procedure lpeUInt16_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) mod UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) mod Int32(PInt32(Right)^); end;
+procedure lpeUInt16_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) mod UInt64(PUInt64(Right)^); end;
+procedure lpeUInt16_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) mod Int64(PInt64(Right)^); end;
+procedure lpeUInt16_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ mod PVariant(Right)^; end;
+procedure lpeInt16_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PUInt8(Right)^); end;
+procedure lpeInt16_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PInt8(Right)^); end;
+procedure lpeInt16_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PUInt16(Right)^); end;
+procedure lpeInt16_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PInt16(Right)^); end;
+procedure lpeInt16_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) mod Int64(PUInt32(Right)^); end;
+procedure lpeInt16_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) mod Int32(PInt32(Right)^); end;
+procedure lpeInt16_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) mod Int64(PUInt64(Right)^); end;
+procedure lpeInt16_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) mod Int64(PInt64(Right)^); end;
+procedure lpeInt16_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ mod PVariant(Right)^; end;
+procedure lpeUInt32_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ mod PUInt8(Right)^; end;
+procedure lpeUInt32_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) mod Int64(PInt8(Right)^); end;
+procedure lpeUInt32_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ mod PUInt16(Right)^; end;
+procedure lpeUInt32_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) mod Int64(PInt16(Right)^); end;
+procedure lpeUInt32_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ mod PUInt32(Right)^; end;
+procedure lpeUInt32_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) mod Int64(PInt32(Right)^); end;
+procedure lpeUInt32_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) mod UInt64(PUInt64(Right)^); end;
+procedure lpeUInt32_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) mod Int64(PInt64(Right)^); end;
+procedure lpeUInt32_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ mod PVariant(Right)^; end;
+procedure lpeInt32_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ mod PUInt8(Right)^; end;
+procedure lpeInt32_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ mod PInt8(Right)^; end;
+procedure lpeInt32_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ mod PUInt16(Right)^; end;
+procedure lpeInt32_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ mod PInt16(Right)^; end;
+procedure lpeInt32_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) mod Int64(PUInt32(Right)^); end;
+procedure lpeInt32_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ mod PInt32(Right)^; end;
+procedure lpeInt32_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) mod Int64(PUInt64(Right)^); end;
+procedure lpeInt32_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) mod Int64(PInt64(Right)^); end;
+procedure lpeInt32_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ mod PVariant(Right)^; end;
+procedure lpeUInt64_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ mod PUInt8(Right)^; end;
+procedure lpeUInt64_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) mod Int64(PInt8(Right)^); end;
+procedure lpeUInt64_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ mod PUInt16(Right)^; end;
+procedure lpeUInt64_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) mod Int64(PInt16(Right)^); end;
+procedure lpeUInt64_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ mod PUInt32(Right)^; end;
+procedure lpeUInt64_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) mod Int64(PInt32(Right)^); end;
+procedure lpeUInt64_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ mod PUInt64(Right)^; end;
+procedure lpeUInt64_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) mod Int64(PInt64(Right)^); end;
+procedure lpeUInt64_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ mod PVariant(Right)^; end;
+procedure lpeInt64_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ mod PUInt8(Right)^; end;
+procedure lpeInt64_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ mod PInt8(Right)^; end;
+procedure lpeInt64_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ mod PUInt16(Right)^; end;
+procedure lpeInt64_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ mod PInt16(Right)^; end;
+procedure lpeInt64_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ mod PUInt32(Right)^; end;
+procedure lpeInt64_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ mod PInt32(Right)^; end;
+procedure lpeInt64_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ mod PUInt64(Right)^; end;
+procedure lpeInt64_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ mod PInt64(Right)^; end;
+procedure lpeInt64_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ mod PVariant(Right)^; end;
+procedure lpeVariant_MOD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PUInt8(Right)^; end;
+procedure lpeVariant_MOD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PInt8(Right)^; end;
+procedure lpeVariant_MOD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PUInt16(Right)^; end;
+procedure lpeVariant_MOD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PInt16(Right)^; end;
+procedure lpeVariant_MOD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PUInt32(Right)^; end;
+procedure lpeVariant_MOD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PInt32(Right)^; end;
+procedure lpeVariant_MOD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PUInt64(Right)^; end;
+procedure lpeVariant_MOD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PInt64(Right)^; end;
+procedure lpeVariant_MOD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ mod PVariant(Right)^; end;
+procedure lpeUInt8_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) * UInt32(PUInt8(Right)^); end;
+procedure lpeUInt8_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) * Int32(PInt8(Right)^); end;
+procedure lpeUInt8_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) * UInt32(PUInt16(Right)^); end;
+procedure lpeUInt8_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) * Int32(PInt16(Right)^); end;
+procedure lpeUInt8_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) * UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) * Int32(PInt32(Right)^); end;
+procedure lpeUInt8_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) * UInt64(PUInt64(Right)^); end;
+procedure lpeUInt8_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) * Int64(PInt64(Right)^); end;
+procedure lpeUInt8_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt8(Left)^ * PSingle(Right)^; end;
+procedure lpeUInt8_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt8(Left)^ * PDouble(Right)^; end;
+procedure lpeUInt8_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt8(Left)^ * PCurrency(Right)^; end;
+procedure lpeUInt8_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ * PExtended(Right)^; end;
+procedure lpeUInt8_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ * PVariant(Right)^; end;
+procedure lpeInt8_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PUInt8(Right)^); end;
+procedure lpeInt8_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PInt8(Right)^); end;
+procedure lpeInt8_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PUInt16(Right)^); end;
+procedure lpeInt8_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PInt16(Right)^); end;
+procedure lpeInt8_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) * Int64(PUInt32(Right)^); end;
+procedure lpeInt8_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) * Int32(PInt32(Right)^); end;
+procedure lpeInt8_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) * UInt64(PUInt64(Right)^); end;
+procedure lpeInt8_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) * Int64(PInt64(Right)^); end;
+procedure lpeInt8_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt8(Left)^ * PSingle(Right)^; end;
+procedure lpeInt8_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt8(Left)^ * PDouble(Right)^; end;
+procedure lpeInt8_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt8(Left)^ * PCurrency(Right)^; end;
+procedure lpeInt8_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ * PExtended(Right)^; end;
+procedure lpeInt8_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ * PVariant(Right)^; end;
+procedure lpeUInt16_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) * UInt32(PUInt8(Right)^); end;
+procedure lpeUInt16_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) * Int32(PInt8(Right)^); end;
+procedure lpeUInt16_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) * UInt32(PUInt16(Right)^); end;
+procedure lpeUInt16_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) * Int32(PInt16(Right)^); end;
+procedure lpeUInt16_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) * UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) * Int32(PInt32(Right)^); end;
+procedure lpeUInt16_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) * UInt64(PUInt64(Right)^); end;
+procedure lpeUInt16_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) * Int64(PInt64(Right)^); end;
+procedure lpeUInt16_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt16(Left)^ * PSingle(Right)^; end;
+procedure lpeUInt16_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt16(Left)^ * PDouble(Right)^; end;
+procedure lpeUInt16_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt16(Left)^ * PCurrency(Right)^; end;
+procedure lpeUInt16_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ * PExtended(Right)^; end;
+procedure lpeUInt16_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ * PVariant(Right)^; end;
+procedure lpeInt16_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PUInt8(Right)^); end;
+procedure lpeInt16_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PInt8(Right)^); end;
+procedure lpeInt16_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PUInt16(Right)^); end;
+procedure lpeInt16_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PInt16(Right)^); end;
+procedure lpeInt16_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) * Int64(PUInt32(Right)^); end;
+procedure lpeInt16_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) * Int32(PInt32(Right)^); end;
+procedure lpeInt16_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) * UInt64(PUInt64(Right)^); end;
+procedure lpeInt16_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) * Int64(PInt64(Right)^); end;
+procedure lpeInt16_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt16(Left)^ * PSingle(Right)^; end;
+procedure lpeInt16_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt16(Left)^ * PDouble(Right)^; end;
+procedure lpeInt16_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt16(Left)^ * PCurrency(Right)^; end;
+procedure lpeInt16_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ * PExtended(Right)^; end;
+procedure lpeInt16_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ * PVariant(Right)^; end;
+procedure lpeUInt32_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ * PUInt8(Right)^; end;
+procedure lpeUInt32_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) * Int64(PInt8(Right)^); end;
+procedure lpeUInt32_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ * PUInt16(Right)^; end;
+procedure lpeUInt32_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) * Int64(PInt16(Right)^); end;
+procedure lpeUInt32_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ * PUInt32(Right)^; end;
+procedure lpeUInt32_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) * Int64(PInt32(Right)^); end;
+procedure lpeUInt32_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) * UInt64(PUInt64(Right)^); end;
+procedure lpeUInt32_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) * Int64(PInt64(Right)^); end;
+procedure lpeUInt32_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt32(Left)^ * PSingle(Right)^; end;
+procedure lpeUInt32_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt32(Left)^ * PDouble(Right)^; end;
+procedure lpeUInt32_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt32(Left)^ * PCurrency(Right)^; end;
+procedure lpeUInt32_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ * PExtended(Right)^; end;
+procedure lpeUInt32_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ * PVariant(Right)^; end;
+procedure lpeInt32_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ * PUInt8(Right)^; end;
+procedure lpeInt32_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ * PInt8(Right)^; end;
+procedure lpeInt32_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ * PUInt16(Right)^; end;
+procedure lpeInt32_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ * PInt16(Right)^; end;
+procedure lpeInt32_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) * Int64(PUInt32(Right)^); end;
+procedure lpeInt32_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ * PInt32(Right)^; end;
+procedure lpeInt32_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) * UInt64(PUInt64(Right)^); end;
+procedure lpeInt32_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) * Int64(PInt64(Right)^); end;
+procedure lpeInt32_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt32(Left)^ * PSingle(Right)^; end;
+procedure lpeInt32_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt32(Left)^ * PDouble(Right)^; end;
+procedure lpeInt32_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt32(Left)^ * PCurrency(Right)^; end;
+procedure lpeInt32_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ * PExtended(Right)^; end;
+procedure lpeInt32_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ * PVariant(Right)^; end;
+procedure lpeUInt64_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ * PUInt8(Right)^; end;
+procedure lpeUInt64_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ * PInt8(Right)^; end;
+procedure lpeUInt64_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ * PUInt16(Right)^; end;
+procedure lpeUInt64_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ * PInt16(Right)^; end;
+procedure lpeUInt64_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ * PUInt32(Right)^; end;
+procedure lpeUInt64_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ * PInt32(Right)^; end;
+procedure lpeUInt64_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ * PUInt64(Right)^; end;
+procedure lpeUInt64_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) * Int64(PInt64(Right)^); end;
+procedure lpeUInt64_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt64(Left)^ * PSingle(Right)^; end;
+procedure lpeUInt64_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt64(Left)^ * PDouble(Right)^; end;
+procedure lpeUInt64_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt64(Left)^ * PCurrency(Right)^; end;
+procedure lpeUInt64_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ * PExtended(Right)^; end;
+procedure lpeUInt64_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ * PVariant(Right)^; end;
+procedure lpeInt64_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ * PUInt8(Right)^; end;
+procedure lpeInt64_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ * PInt8(Right)^; end;
+procedure lpeInt64_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ * PUInt16(Right)^; end;
+procedure lpeInt64_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ * PInt16(Right)^; end;
+procedure lpeInt64_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ * PUInt32(Right)^; end;
+procedure lpeInt64_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ * PInt32(Right)^; end;
+procedure lpeInt64_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ * PUInt64(Right)^; end;
+procedure lpeInt64_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ * PInt64(Right)^; end;
+procedure lpeInt64_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt64(Left)^ * PSingle(Right)^; end;
+procedure lpeInt64_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt64(Left)^ * PDouble(Right)^; end;
+procedure lpeInt64_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt64(Left)^ * PCurrency(Right)^; end;
+procedure lpeInt64_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ * PExtended(Right)^; end;
+procedure lpeInt64_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ * PVariant(Right)^; end;
+procedure lpeSingle_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PUInt8(Right)^; end;
+procedure lpeSingle_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PInt8(Right)^; end;
+procedure lpeSingle_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PUInt16(Right)^; end;
+procedure lpeSingle_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PInt16(Right)^; end;
+procedure lpeSingle_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PUInt32(Right)^; end;
+procedure lpeSingle_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PInt32(Right)^; end;
+procedure lpeSingle_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PUInt64(Right)^; end;
+procedure lpeSingle_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PInt64(Right)^; end;
+procedure lpeSingle_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ * PSingle(Right)^; end;
+procedure lpeSingle_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PSingle(Left)^ * PDouble(Right)^; end;
+procedure lpeSingle_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PSingle(Left)^ * PCurrency(Right)^; end;
+procedure lpeSingle_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PSingle(Left)^ * PExtended(Right)^; end;
+procedure lpeSingle_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PSingle(Left)^ * PVariant(Right)^; end;
+procedure lpeDouble_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PUInt8(Right)^; end;
+procedure lpeDouble_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PInt8(Right)^; end;
+procedure lpeDouble_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PUInt16(Right)^; end;
+procedure lpeDouble_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PInt16(Right)^; end;
+procedure lpeDouble_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PUInt32(Right)^; end;
+procedure lpeDouble_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PInt32(Right)^; end;
+procedure lpeDouble_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PUInt64(Right)^; end;
+procedure lpeDouble_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PInt64(Right)^; end;
+procedure lpeDouble_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PSingle(Right)^; end;
+procedure lpeDouble_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ * PDouble(Right)^; end;
+procedure lpeDouble_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PDouble(Left)^ * PCurrency(Right)^; end;
+procedure lpeDouble_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PDouble(Left)^ * PExtended(Right)^; end;
+procedure lpeDouble_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PDouble(Left)^ * PVariant(Right)^; end;
+procedure lpeCurrency_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PUInt8(Right)^; end;
+procedure lpeCurrency_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PInt8(Right)^; end;
+procedure lpeCurrency_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PUInt16(Right)^; end;
+procedure lpeCurrency_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PInt16(Right)^; end;
+procedure lpeCurrency_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PUInt32(Right)^; end;
+procedure lpeCurrency_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PInt32(Right)^; end;
+procedure lpeCurrency_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PUInt64(Right)^; end;
+procedure lpeCurrency_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PInt64(Right)^; end;
+procedure lpeCurrency_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PSingle(Right)^; end;
+procedure lpeCurrency_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PDouble(Right)^; end;
+procedure lpeCurrency_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PCurrency(Right)^; end;
+procedure lpeCurrency_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ * PExtended(Right)^; end;
+procedure lpeCurrency_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PCurrency(Left)^ * PVariant(Right)^; end;
+procedure lpeExtended_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PUInt8(Right)^; end;
+procedure lpeExtended_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PInt8(Right)^; end;
+procedure lpeExtended_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PUInt16(Right)^; end;
+procedure lpeExtended_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PInt16(Right)^; end;
+procedure lpeExtended_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PUInt32(Right)^; end;
+procedure lpeExtended_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PInt32(Right)^; end;
+procedure lpeExtended_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PUInt64(Right)^; end;
+procedure lpeExtended_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PInt64(Right)^; end;
+procedure lpeExtended_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PSingle(Right)^; end;
+procedure lpeExtended_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PDouble(Right)^; end;
+procedure lpeExtended_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PExtended(Left)^ * PCurrency(Right)^; end;
+procedure lpeExtended_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ * PExtended(Right)^; end;
+procedure lpeExtended_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PExtended(Left)^ * PVariant(Right)^; end;
+procedure lpeVariant_MUL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PUInt8(Right)^; end;
+procedure lpeVariant_MUL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PInt8(Right)^; end;
+procedure lpeVariant_MUL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PUInt16(Right)^; end;
+procedure lpeVariant_MUL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PInt16(Right)^; end;
+procedure lpeVariant_MUL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PUInt32(Right)^; end;
+procedure lpeVariant_MUL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PInt32(Right)^; end;
+procedure lpeVariant_MUL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PUInt64(Right)^; end;
+procedure lpeVariant_MUL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PInt64(Right)^; end;
+procedure lpeVariant_MUL_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PSingle(Right)^; end;
+procedure lpeVariant_MUL_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PDouble(Right)^; end;
+procedure lpeVariant_MUL_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PCurrency(Right)^; end;
+procedure lpeVariant_MUL_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PExtended(Right)^; end;
+procedure lpeVariant_MUL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ * PVariant(Right)^; end;
+procedure lpeUInt8_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := not PUInt8(Left)^; end;
+procedure lpeInt8_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := not PInt8(Left)^; end;
+procedure lpeUInt16_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := not PUInt16(Left)^; end;
+procedure lpeInt16_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := not PInt16(Left)^; end;
+procedure lpeUInt32_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := not PUInt32(Left)^; end;
+procedure lpeInt32_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := not PInt32(Left)^; end;
+procedure lpeUInt64_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := not PUInt64(Left)^; end;
+procedure lpeInt64_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := not PInt64(Left)^; end;
+procedure lpeVariant_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := not PVariant(Left)^; end;
+procedure lpeUInt8_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PUInt8(Left)^ or PUInt8(Right)^; end;
+procedure lpeUInt8_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) or Int32(PInt8(Right)^); end;
+procedure lpeUInt8_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := UInt16(PUInt8(Left)^) or UInt16(PUInt16(Right)^); end;
+procedure lpeUInt8_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) or Int32(PInt16(Right)^); end;
+procedure lpeUInt8_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) or UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) or Int32(PInt32(Right)^); end;
+procedure lpeUInt8_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) or UInt64(PUInt64(Right)^); end;
+procedure lpeUInt8_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) or Int64(PInt64(Right)^); end;
+procedure lpeUInt8_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ or PVariant(Right)^; end;
+procedure lpeInt8_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) or Int32(PUInt8(Right)^); end;
+procedure lpeInt8_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PInt8(Left)^ or PInt8(Right)^; end;
+procedure lpeInt8_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) or Int32(PUInt16(Right)^); end;
+procedure lpeInt8_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := Int16(PInt8(Left)^) or Int16(PInt16(Right)^); end;
+procedure lpeInt8_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) or Int64(PUInt32(Right)^); end;
+procedure lpeInt8_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) or Int32(PInt32(Right)^); end;
+procedure lpeInt8_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) or UInt64(PUInt64(Right)^); end;
+procedure lpeInt8_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) or Int64(PInt64(Right)^); end;
+procedure lpeInt8_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ or PVariant(Right)^; end;
+procedure lpeUInt16_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^ or PUInt8(Right)^; end;
+procedure lpeUInt16_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) or Int32(PInt8(Right)^); end;
+procedure lpeUInt16_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^ or PUInt16(Right)^; end;
+procedure lpeUInt16_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) or Int32(PInt16(Right)^); end;
+procedure lpeUInt16_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) or UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) or Int32(PInt32(Right)^); end;
+procedure lpeUInt16_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) or UInt64(PUInt64(Right)^); end;
+procedure lpeUInt16_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) or Int64(PInt64(Right)^); end;
+procedure lpeUInt16_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ or PVariant(Right)^; end;
+procedure lpeInt16_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) or Int32(PUInt8(Right)^); end;
+procedure lpeInt16_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt16(Left)^ or PInt8(Right)^; end;
+procedure lpeInt16_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) or Int32(PUInt16(Right)^); end;
+procedure lpeInt16_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt16(Left)^ or PInt16(Right)^; end;
+procedure lpeInt16_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) or Int64(PUInt32(Right)^); end;
+procedure lpeInt16_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) or Int32(PInt32(Right)^); end;
+procedure lpeInt16_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) or UInt64(PUInt64(Right)^); end;
+procedure lpeInt16_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) or Int64(PInt64(Right)^); end;
+procedure lpeInt16_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ or PVariant(Right)^; end;
+procedure lpeUInt32_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ or PUInt8(Right)^; end;
+procedure lpeUInt32_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) or Int64(PInt8(Right)^); end;
+procedure lpeUInt32_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ or PUInt16(Right)^; end;
+procedure lpeUInt32_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) or Int64(PInt16(Right)^); end;
+procedure lpeUInt32_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ or PUInt32(Right)^; end;
+procedure lpeUInt32_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) or Int64(PInt32(Right)^); end;
+procedure lpeUInt32_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) or UInt64(PUInt64(Right)^); end;
+procedure lpeUInt32_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) or Int64(PInt64(Right)^); end;
+procedure lpeUInt32_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ or PVariant(Right)^; end;
+procedure lpeInt32_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ or PUInt8(Right)^; end;
+procedure lpeInt32_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ or PInt8(Right)^; end;
+procedure lpeInt32_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ or PUInt16(Right)^; end;
+procedure lpeInt32_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ or PInt16(Right)^; end;
+procedure lpeInt32_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) or Int64(PUInt32(Right)^); end;
+procedure lpeInt32_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ or PInt32(Right)^; end;
+procedure lpeInt32_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) or UInt64(PUInt64(Right)^); end;
+procedure lpeInt32_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) or Int64(PInt64(Right)^); end;
+procedure lpeInt32_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ or PVariant(Right)^; end;
+procedure lpeUInt64_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ or PUInt8(Right)^; end;
+procedure lpeUInt64_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ or PInt8(Right)^; end;
+procedure lpeUInt64_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ or PUInt16(Right)^; end;
+procedure lpeUInt64_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ or PInt16(Right)^; end;
+procedure lpeUInt64_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ or PUInt32(Right)^; end;
+procedure lpeUInt64_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ or PInt32(Right)^; end;
+procedure lpeUInt64_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ or PUInt64(Right)^; end;
+procedure lpeUInt64_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) or Int64(PInt64(Right)^); end;
+procedure lpeUInt64_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ or PVariant(Right)^; end;
+procedure lpeInt64_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ or PUInt8(Right)^; end;
+procedure lpeInt64_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ or PInt8(Right)^; end;
+procedure lpeInt64_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ or PUInt16(Right)^; end;
+procedure lpeInt64_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ or PInt16(Right)^; end;
+procedure lpeInt64_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ or PUInt32(Right)^; end;
+procedure lpeInt64_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ or PInt32(Right)^; end;
+procedure lpeInt64_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ or PUInt64(Right)^; end;
+procedure lpeInt64_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ or PInt64(Right)^; end;
+procedure lpeInt64_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ or PVariant(Right)^; end;
+procedure lpeVariant_OR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PUInt8(Right)^; end;
+procedure lpeVariant_OR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PInt8(Right)^; end;
+procedure lpeVariant_OR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PUInt16(Right)^; end;
+procedure lpeVariant_OR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PInt16(Right)^; end;
+procedure lpeVariant_OR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PUInt32(Right)^; end;
+procedure lpeVariant_OR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PInt32(Right)^; end;
+procedure lpeVariant_OR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PUInt64(Right)^; end;
+procedure lpeVariant_OR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PInt64(Right)^; end;
+procedure lpeVariant_OR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ or PVariant(Right)^; end;
+procedure lpeUInt8_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) + UInt32(PUInt8(Right)^); end;
+procedure lpeUInt8_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) + Int32(PInt8(Right)^); end;
+procedure lpeUInt8_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) + UInt32(PUInt16(Right)^); end;
+procedure lpeUInt8_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) + Int32(PInt16(Right)^); end;
+procedure lpeUInt8_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) + UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) + Int32(PInt32(Right)^); end;
+procedure lpeUInt8_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) + UInt64(PUInt64(Right)^); end;
+procedure lpeUInt8_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) + Int64(PInt64(Right)^); end;
+procedure lpeUInt8_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt8(Left)^ + PSingle(Right)^; end;
+procedure lpeUInt8_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt8(Left)^ + PDouble(Right)^; end;
+procedure lpeUInt8_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt8(Left)^ + PCurrency(Right)^; end;
+procedure lpeUInt8_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt8(Left)^ + PExtended(Right)^; end;
+procedure lpeUInt8_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ + PVariant(Right)^; end;
+procedure lpeInt8_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PUInt8(Right)^); end;
+procedure lpeInt8_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PInt8(Right)^); end;
+procedure lpeInt8_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PUInt16(Right)^); end;
+procedure lpeInt8_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PInt16(Right)^); end;
+procedure lpeInt8_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) + Int64(PUInt32(Right)^); end;
+procedure lpeInt8_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) + Int32(PInt32(Right)^); end;
+procedure lpeInt8_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) + UInt64(PUInt64(Right)^); end;
+procedure lpeInt8_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) + Int64(PInt64(Right)^); end;
+procedure lpeInt8_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt8(Left)^ + PSingle(Right)^; end;
+procedure lpeInt8_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt8(Left)^ + PDouble(Right)^; end;
+procedure lpeInt8_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt8(Left)^ + PCurrency(Right)^; end;
+procedure lpeInt8_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt8(Left)^ + PExtended(Right)^; end;
+procedure lpeInt8_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ + PVariant(Right)^; end;
+procedure lpeUInt16_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) + UInt32(PUInt8(Right)^); end;
+procedure lpeUInt16_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) + Int32(PInt8(Right)^); end;
+procedure lpeUInt16_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) + UInt32(PUInt16(Right)^); end;
+procedure lpeUInt16_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) + Int32(PInt16(Right)^); end;
+procedure lpeUInt16_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) + UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) + Int32(PInt32(Right)^); end;
+procedure lpeUInt16_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) + UInt64(PUInt64(Right)^); end;
+procedure lpeUInt16_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) + Int64(PInt64(Right)^); end;
+procedure lpeUInt16_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt16(Left)^ + PSingle(Right)^; end;
+procedure lpeUInt16_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt16(Left)^ + PDouble(Right)^; end;
+procedure lpeUInt16_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt16(Left)^ + PCurrency(Right)^; end;
+procedure lpeUInt16_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt16(Left)^ + PExtended(Right)^; end;
+procedure lpeUInt16_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ + PVariant(Right)^; end;
+procedure lpeInt16_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PUInt8(Right)^); end;
+procedure lpeInt16_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PInt8(Right)^); end;
+procedure lpeInt16_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PUInt16(Right)^); end;
+procedure lpeInt16_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PInt16(Right)^); end;
+procedure lpeInt16_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) + Int64(PUInt32(Right)^); end;
+procedure lpeInt16_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) + Int32(PInt32(Right)^); end;
+procedure lpeInt16_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) + UInt64(PUInt64(Right)^); end;
+procedure lpeInt16_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) + Int64(PInt64(Right)^); end;
+procedure lpeInt16_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt16(Left)^ + PSingle(Right)^; end;
+procedure lpeInt16_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt16(Left)^ + PDouble(Right)^; end;
+procedure lpeInt16_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt16(Left)^ + PCurrency(Right)^; end;
+procedure lpeInt16_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt16(Left)^ + PExtended(Right)^; end;
+procedure lpeInt16_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ + PVariant(Right)^; end;
+procedure lpeUInt32_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ + PUInt8(Right)^; end;
+procedure lpeUInt32_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) + Int64(PInt8(Right)^); end;
+procedure lpeUInt32_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ + PUInt16(Right)^; end;
+procedure lpeUInt32_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) + Int64(PInt16(Right)^); end;
+procedure lpeUInt32_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ + PUInt32(Right)^; end;
+procedure lpeUInt32_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) + Int64(PInt32(Right)^); end;
+procedure lpeUInt32_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) + UInt64(PUInt64(Right)^); end;
+procedure lpeUInt32_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) + Int64(PInt64(Right)^); end;
+procedure lpeUInt32_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt32(Left)^ + PSingle(Right)^; end;
+procedure lpeUInt32_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt32(Left)^ + PDouble(Right)^; end;
+procedure lpeUInt32_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt32(Left)^ + PCurrency(Right)^; end;
+procedure lpeUInt32_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt32(Left)^ + PExtended(Right)^; end;
+procedure lpeUInt32_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ + PVariant(Right)^; end;
+procedure lpeInt32_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ + PUInt8(Right)^; end;
+procedure lpeInt32_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ + PInt8(Right)^; end;
+procedure lpeInt32_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ + PUInt16(Right)^; end;
+procedure lpeInt32_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ + PInt16(Right)^; end;
+procedure lpeInt32_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) + Int64(PUInt32(Right)^); end;
+procedure lpeInt32_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ + PInt32(Right)^; end;
+procedure lpeInt32_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) + UInt64(PUInt64(Right)^); end;
+procedure lpeInt32_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) + Int64(PInt64(Right)^); end;
+procedure lpeInt32_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt32(Left)^ + PSingle(Right)^; end;
+procedure lpeInt32_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt32(Left)^ + PDouble(Right)^; end;
+procedure lpeInt32_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt32(Left)^ + PCurrency(Right)^; end;
+procedure lpeInt32_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt32(Left)^ + PExtended(Right)^; end;
+procedure lpeInt32_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ + PVariant(Right)^; end;
+procedure lpeUInt64_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ + PUInt8(Right)^; end;
+procedure lpeUInt64_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ + PInt8(Right)^; end;
+procedure lpeUInt64_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ + PUInt16(Right)^; end;
+procedure lpeUInt64_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ + PInt16(Right)^; end;
+procedure lpeUInt64_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ + PUInt32(Right)^; end;
+procedure lpeUInt64_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ + PInt32(Right)^; end;
+procedure lpeUInt64_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ + PUInt64(Right)^; end;
+procedure lpeUInt64_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) + Int64(PInt64(Right)^); end;
+procedure lpeUInt64_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PUInt64(Left)^ + PSingle(Right)^; end;
+procedure lpeUInt64_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PUInt64(Left)^ + PDouble(Right)^; end;
+procedure lpeUInt64_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PUInt64(Left)^ + PCurrency(Right)^; end;
+procedure lpeUInt64_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PUInt64(Left)^ + PExtended(Right)^; end;
+procedure lpeUInt64_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ + PVariant(Right)^; end;
+procedure lpeInt64_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ + PUInt8(Right)^; end;
+procedure lpeInt64_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ + PInt8(Right)^; end;
+procedure lpeInt64_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ + PUInt16(Right)^; end;
+procedure lpeInt64_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ + PInt16(Right)^; end;
+procedure lpeInt64_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ + PUInt32(Right)^; end;
+procedure lpeInt64_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ + PInt32(Right)^; end;
+procedure lpeInt64_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ + PUInt64(Right)^; end;
+procedure lpeInt64_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ + PInt64(Right)^; end;
+procedure lpeInt64_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PInt64(Left)^ + PSingle(Right)^; end;
+procedure lpeInt64_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PInt64(Left)^ + PDouble(Right)^; end;
+procedure lpeInt64_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PInt64(Left)^ + PCurrency(Right)^; end;
+procedure lpeInt64_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PInt64(Left)^ + PExtended(Right)^; end;
+procedure lpeInt64_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ + PVariant(Right)^; end;
+procedure lpeSingle_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PUInt8(Right)^; end;
+procedure lpeSingle_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PInt8(Right)^; end;
+procedure lpeSingle_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PUInt16(Right)^; end;
+procedure lpeSingle_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PInt16(Right)^; end;
+procedure lpeSingle_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PUInt32(Right)^; end;
+procedure lpeSingle_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PInt32(Right)^; end;
+procedure lpeSingle_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PUInt64(Right)^; end;
+procedure lpeSingle_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PInt64(Right)^; end;
+procedure lpeSingle_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := PSingle(Left)^ + PSingle(Right)^; end;
+procedure lpeSingle_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PSingle(Left)^ + PDouble(Right)^; end;
+procedure lpeSingle_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PSingle(Left)^ + PCurrency(Right)^; end;
+procedure lpeSingle_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PSingle(Left)^ + PExtended(Right)^; end;
+procedure lpeSingle_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PSingle(Left)^ + PVariant(Right)^; end;
+procedure lpeDouble_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PUInt8(Right)^; end;
+procedure lpeDouble_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PInt8(Right)^; end;
+procedure lpeDouble_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PUInt16(Right)^; end;
+procedure lpeDouble_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PInt16(Right)^; end;
+procedure lpeDouble_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PUInt32(Right)^; end;
+procedure lpeDouble_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PInt32(Right)^; end;
+procedure lpeDouble_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PUInt64(Right)^; end;
+procedure lpeDouble_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PInt64(Right)^; end;
+procedure lpeDouble_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PSingle(Right)^; end;
+procedure lpeDouble_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := PDouble(Left)^ + PDouble(Right)^; end;
+procedure lpeDouble_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PDouble(Left)^ + PCurrency(Right)^; end;
+procedure lpeDouble_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PDouble(Left)^ + PExtended(Right)^; end;
+procedure lpeDouble_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PDouble(Left)^ + PVariant(Right)^; end;
+procedure lpeCurrency_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PUInt8(Right)^; end;
+procedure lpeCurrency_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PInt8(Right)^; end;
+procedure lpeCurrency_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PUInt16(Right)^; end;
+procedure lpeCurrency_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PInt16(Right)^; end;
+procedure lpeCurrency_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PUInt32(Right)^; end;
+procedure lpeCurrency_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PInt32(Right)^; end;
+procedure lpeCurrency_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PUInt64(Right)^; end;
+procedure lpeCurrency_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PInt64(Right)^; end;
+procedure lpeCurrency_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PSingle(Right)^; end;
+procedure lpeCurrency_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PDouble(Right)^; end;
+procedure lpeCurrency_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PCurrency(Right)^; end;
+procedure lpeCurrency_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PCurrency(Left)^ + PExtended(Right)^; end;
+procedure lpeCurrency_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PCurrency(Left)^ + PVariant(Right)^; end;
+procedure lpeExtended_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PUInt8(Right)^; end;
+procedure lpeExtended_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PInt8(Right)^; end;
+procedure lpeExtended_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PUInt16(Right)^; end;
+procedure lpeExtended_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PInt16(Right)^; end;
+procedure lpeExtended_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PUInt32(Right)^; end;
+procedure lpeExtended_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PInt32(Right)^; end;
+procedure lpeExtended_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PUInt64(Right)^; end;
+procedure lpeExtended_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PInt64(Right)^; end;
+procedure lpeExtended_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PSingle(Right)^; end;
+procedure lpeExtended_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PDouble(Right)^; end;
+procedure lpeExtended_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := PExtended(Left)^ + PCurrency(Right)^; end;
+procedure lpeExtended_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := PExtended(Left)^ + PExtended(Right)^; end;
+procedure lpeExtended_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PExtended(Left)^ + PVariant(Right)^; end;
+procedure lpeVariant_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PUInt8(Right)^; end;
+procedure lpeVariant_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PInt8(Right)^; end;
+procedure lpeVariant_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PUInt16(Right)^; end;
+procedure lpeVariant_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PInt16(Right)^; end;
+procedure lpeVariant_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PUInt32(Right)^; end;
+procedure lpeVariant_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PInt32(Right)^; end;
+procedure lpeVariant_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PUInt64(Right)^; end;
+procedure lpeVariant_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PInt64(Right)^; end;
+procedure lpeVariant_ADD_Single(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PSingle(Right)^; end;
+procedure lpeVariant_ADD_Double(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PDouble(Right)^; end;
+procedure lpeVariant_ADD_Currency(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PCurrency(Right)^; end;
+procedure lpeVariant_ADD_Extended(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PExtended(Right)^; end;
+procedure lpeVariant_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ + PVariant(Right)^; end;
+procedure lpeUInt8_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PUInt8(Right)^); end;
+procedure lpeUInt8_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PInt8(Right)^); end;
+procedure lpeUInt8_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PUInt16(Right)^); end;
+procedure lpeUInt8_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PInt16(Right)^); end;
+procedure lpeUInt8_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PInt32(Right)^); end;
+procedure lpeUInt8_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PUInt64(Right)^); end;
+procedure lpeUInt8_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shl UInt32(PInt64(Right)^); end;
+procedure lpeUInt8_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ shl PVariant(Right)^; end;
+procedure lpeInt8_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PUInt8(Right)^); end;
+procedure lpeInt8_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PInt8(Right)^); end;
+procedure lpeInt8_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PUInt16(Right)^); end;
+procedure lpeInt8_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PInt16(Right)^); end;
+procedure lpeInt8_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PUInt32(Right)^); end;
+procedure lpeInt8_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PInt32(Right)^); end;
+procedure lpeInt8_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PUInt64(Right)^); end;
+procedure lpeInt8_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shl Int32(PInt64(Right)^); end;
+procedure lpeInt8_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ shl PVariant(Right)^; end;
+procedure lpeUInt16_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PUInt8(Right)^); end;
+procedure lpeUInt16_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PInt8(Right)^); end;
+procedure lpeUInt16_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PUInt16(Right)^); end;
+procedure lpeUInt16_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PInt16(Right)^); end;
+procedure lpeUInt16_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PInt32(Right)^); end;
+procedure lpeUInt16_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PUInt64(Right)^); end;
+procedure lpeUInt16_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shl UInt32(PInt64(Right)^); end;
+procedure lpeUInt16_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ shl PVariant(Right)^; end;
+procedure lpeInt16_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PUInt8(Right)^); end;
+procedure lpeInt16_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PInt8(Right)^); end;
+procedure lpeInt16_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PUInt16(Right)^); end;
+procedure lpeInt16_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PInt16(Right)^); end;
+procedure lpeInt16_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PUInt32(Right)^); end;
+procedure lpeInt16_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PInt32(Right)^); end;
+procedure lpeInt16_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PUInt64(Right)^); end;
+procedure lpeInt16_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shl Int32(PInt64(Right)^); end;
+procedure lpeInt16_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ shl PVariant(Right)^; end;
+procedure lpeUInt32_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shl PUInt8(Right)^; end;
+procedure lpeUInt32_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shl PInt8(Right)^; end;
+procedure lpeUInt32_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shl PUInt16(Right)^; end;
+procedure lpeUInt32_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shl PInt16(Right)^; end;
+procedure lpeUInt32_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shl PUInt32(Right)^; end;
+procedure lpeUInt32_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shl PInt32(Right)^; end;
+procedure lpeUInt32_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shl PUInt64(Right)^; end;
+procedure lpeUInt32_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shl PInt64(Right)^; end;
+procedure lpeUInt32_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ shl PVariant(Right)^; end;
+procedure lpeInt32_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shl PUInt8(Right)^; end;
+procedure lpeInt32_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shl PInt8(Right)^; end;
+procedure lpeInt32_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shl PUInt16(Right)^; end;
+procedure lpeInt32_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shl PInt16(Right)^; end;
+procedure lpeInt32_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shl PUInt32(Right)^; end;
+procedure lpeInt32_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shl PInt32(Right)^; end;
+procedure lpeInt32_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shl PUInt64(Right)^; end;
+procedure lpeInt32_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shl PInt64(Right)^; end;
+procedure lpeInt32_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ shl PVariant(Right)^; end;
+procedure lpeUInt64_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shl PUInt8(Right)^; end;
+procedure lpeUInt64_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shl PInt8(Right)^; end;
+procedure lpeUInt64_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shl PUInt16(Right)^; end;
+procedure lpeUInt64_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shl PInt16(Right)^; end;
+procedure lpeUInt64_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shl PUInt32(Right)^; end;
+procedure lpeUInt64_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shl PInt32(Right)^; end;
+procedure lpeUInt64_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shl PUInt64(Right)^; end;
+procedure lpeUInt64_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shl PInt64(Right)^; end;
+procedure lpeUInt64_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ shl PVariant(Right)^; end;
+procedure lpeInt64_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shl PUInt8(Right)^; end;
+procedure lpeInt64_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shl PInt8(Right)^; end;
+procedure lpeInt64_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shl PUInt16(Right)^; end;
+procedure lpeInt64_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shl PInt16(Right)^; end;
+procedure lpeInt64_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shl PUInt32(Right)^; end;
+procedure lpeInt64_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shl PInt32(Right)^; end;
+procedure lpeInt64_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shl PUInt64(Right)^; end;
+procedure lpeInt64_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shl PInt64(Right)^; end;
+procedure lpeInt64_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ shl PVariant(Right)^; end;
+procedure lpeVariant_SHL_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PUInt8(Right)^; end;
+procedure lpeVariant_SHL_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PInt8(Right)^; end;
+procedure lpeVariant_SHL_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PUInt16(Right)^; end;
+procedure lpeVariant_SHL_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PInt16(Right)^; end;
+procedure lpeVariant_SHL_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PUInt32(Right)^; end;
+procedure lpeVariant_SHL_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PInt32(Right)^; end;
+procedure lpeVariant_SHL_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PUInt64(Right)^; end;
+procedure lpeVariant_SHL_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PInt64(Right)^; end;
+procedure lpeVariant_SHL_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shl PVariant(Right)^; end;
+procedure lpeUInt8_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PUInt8(Right)^); end;
+procedure lpeUInt8_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PInt8(Right)^); end;
+procedure lpeUInt8_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PUInt16(Right)^); end;
+procedure lpeUInt8_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PInt16(Right)^); end;
+procedure lpeUInt8_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PInt32(Right)^); end;
+procedure lpeUInt8_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PUInt64(Right)^); end;
+procedure lpeUInt8_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) shr UInt32(PInt64(Right)^); end;
+procedure lpeUInt8_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ shr PVariant(Right)^; end;
+procedure lpeInt8_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PUInt8(Right)^); end;
+procedure lpeInt8_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PInt8(Right)^); end;
+procedure lpeInt8_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PUInt16(Right)^); end;
+procedure lpeInt8_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PInt16(Right)^); end;
+procedure lpeInt8_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PUInt32(Right)^); end;
+procedure lpeInt8_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PInt32(Right)^); end;
+procedure lpeInt8_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PUInt64(Right)^); end;
+procedure lpeInt8_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) shr Int32(PInt64(Right)^); end;
+procedure lpeInt8_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ shr PVariant(Right)^; end;
+procedure lpeUInt16_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PUInt8(Right)^); end;
+procedure lpeUInt16_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PInt8(Right)^); end;
+procedure lpeUInt16_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PUInt16(Right)^); end;
+procedure lpeUInt16_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PInt16(Right)^); end;
+procedure lpeUInt16_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PInt32(Right)^); end;
+procedure lpeUInt16_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PUInt64(Right)^); end;
+procedure lpeUInt16_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) shr UInt32(PInt64(Right)^); end;
+procedure lpeUInt16_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ shr PVariant(Right)^; end;
+procedure lpeInt16_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PUInt8(Right)^); end;
+procedure lpeInt16_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PInt8(Right)^); end;
+procedure lpeInt16_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PUInt16(Right)^); end;
+procedure lpeInt16_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PInt16(Right)^); end;
+procedure lpeInt16_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PUInt32(Right)^); end;
+procedure lpeInt16_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PInt32(Right)^); end;
+procedure lpeInt16_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PUInt64(Right)^); end;
+procedure lpeInt16_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) shr Int32(PInt64(Right)^); end;
+procedure lpeInt16_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ shr PVariant(Right)^; end;
+procedure lpeUInt32_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shr PUInt8(Right)^; end;
+procedure lpeUInt32_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shr PInt8(Right)^; end;
+procedure lpeUInt32_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shr PUInt16(Right)^; end;
+procedure lpeUInt32_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shr PInt16(Right)^; end;
+procedure lpeUInt32_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shr PUInt32(Right)^; end;
+procedure lpeUInt32_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shr PInt32(Right)^; end;
+procedure lpeUInt32_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shr PUInt64(Right)^; end;
+procedure lpeUInt32_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ shr PInt64(Right)^; end;
+procedure lpeUInt32_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ shr PVariant(Right)^; end;
+procedure lpeInt32_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shr PUInt8(Right)^; end;
+procedure lpeInt32_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shr PInt8(Right)^; end;
+procedure lpeInt32_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shr PUInt16(Right)^; end;
+procedure lpeInt32_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shr PInt16(Right)^; end;
+procedure lpeInt32_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shr PUInt32(Right)^; end;
+procedure lpeInt32_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shr PInt32(Right)^; end;
+procedure lpeInt32_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shr PUInt64(Right)^; end;
+procedure lpeInt32_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ shr PInt64(Right)^; end;
+procedure lpeInt32_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ shr PVariant(Right)^; end;
+procedure lpeUInt64_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shr PUInt8(Right)^; end;
+procedure lpeUInt64_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shr PInt8(Right)^; end;
+procedure lpeUInt64_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shr PUInt16(Right)^; end;
+procedure lpeUInt64_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shr PInt16(Right)^; end;
+procedure lpeUInt64_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shr PUInt32(Right)^; end;
+procedure lpeUInt64_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shr PInt32(Right)^; end;
+procedure lpeUInt64_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shr PUInt64(Right)^; end;
+procedure lpeUInt64_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ shr PInt64(Right)^; end;
+procedure lpeUInt64_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ shr PVariant(Right)^; end;
+procedure lpeInt64_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shr PUInt8(Right)^; end;
+procedure lpeInt64_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shr PInt8(Right)^; end;
+procedure lpeInt64_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shr PUInt16(Right)^; end;
+procedure lpeInt64_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shr PInt16(Right)^; end;
+procedure lpeInt64_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shr PUInt32(Right)^; end;
+procedure lpeInt64_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shr PInt32(Right)^; end;
+procedure lpeInt64_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shr PUInt64(Right)^; end;
+procedure lpeInt64_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ shr PInt64(Right)^; end;
+procedure lpeInt64_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ shr PVariant(Right)^; end;
+procedure lpeVariant_SHR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PUInt8(Right)^; end;
+procedure lpeVariant_SHR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PInt8(Right)^; end;
+procedure lpeVariant_SHR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PUInt16(Right)^; end;
+procedure lpeVariant_SHR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PInt16(Right)^; end;
+procedure lpeVariant_SHR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PUInt32(Right)^; end;
+procedure lpeVariant_SHR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PInt32(Right)^; end;
+procedure lpeVariant_SHR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PUInt64(Right)^; end;
+procedure lpeVariant_SHR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PInt64(Right)^; end;
+procedure lpeVariant_SHR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ shr PVariant(Right)^; end;
+procedure lpeUInt8_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt8(Dest)^ := PUInt8(Left)^ xor PUInt8(Right)^; end;
+procedure lpeUInt8_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) xor Int32(PInt8(Right)^); end;
+procedure lpeUInt8_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := UInt16(PUInt8(Left)^) xor UInt16(PUInt16(Right)^); end;
+procedure lpeUInt8_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) xor Int32(PInt16(Right)^); end;
+procedure lpeUInt8_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt8(Left)^) xor UInt32(PUInt32(Right)^); end;
+procedure lpeUInt8_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt8(Left)^) xor Int32(PInt32(Right)^); end;
+procedure lpeUInt8_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt8(Left)^) xor UInt64(PUInt64(Right)^); end;
+procedure lpeUInt8_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt8(Left)^) xor Int64(PInt64(Right)^); end;
+procedure lpeUInt8_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt8(Left)^ xor PVariant(Right)^; end;
+procedure lpeInt8_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) xor Int32(PUInt8(Right)^); end;
+procedure lpeInt8_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt8(Dest)^ := PInt8(Left)^ xor PInt8(Right)^; end;
+procedure lpeInt8_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) xor Int32(PUInt16(Right)^); end;
+procedure lpeInt8_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := Int16(PInt8(Left)^) xor Int16(PInt16(Right)^); end;
+procedure lpeInt8_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) xor Int64(PUInt32(Right)^); end;
+procedure lpeInt8_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt8(Left)^) xor Int32(PInt32(Right)^); end;
+procedure lpeInt8_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt8(Left)^) xor UInt64(PUInt64(Right)^); end;
+procedure lpeInt8_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt8(Left)^) xor Int64(PInt64(Right)^); end;
+procedure lpeInt8_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt8(Left)^ xor PVariant(Right)^; end;
+procedure lpeUInt16_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^ xor PUInt8(Right)^; end;
+procedure lpeUInt16_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) xor Int32(PInt8(Right)^); end;
+procedure lpeUInt16_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt16(Dest)^ := PUInt16(Left)^ xor PUInt16(Right)^; end;
+procedure lpeUInt16_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) xor Int32(PInt16(Right)^); end;
+procedure lpeUInt16_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := UInt32(PUInt16(Left)^) xor UInt32(PUInt32(Right)^); end;
+procedure lpeUInt16_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PUInt16(Left)^) xor Int32(PInt32(Right)^); end;
+procedure lpeUInt16_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt16(Left)^) xor UInt64(PUInt64(Right)^); end;
+procedure lpeUInt16_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt16(Left)^) xor Int64(PInt64(Right)^); end;
+procedure lpeUInt16_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt16(Left)^ xor PVariant(Right)^; end;
+procedure lpeInt16_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) xor Int32(PUInt8(Right)^); end;
+procedure lpeInt16_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt16(Left)^ xor PInt8(Right)^; end;
+procedure lpeInt16_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) xor Int32(PUInt16(Right)^); end;
+procedure lpeInt16_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt16(Dest)^ := PInt16(Left)^ xor PInt16(Right)^; end;
+procedure lpeInt16_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) xor Int64(PUInt32(Right)^); end;
+procedure lpeInt16_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := Int32(PInt16(Left)^) xor Int32(PInt32(Right)^); end;
+procedure lpeInt16_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt16(Left)^) xor UInt64(PUInt64(Right)^); end;
+procedure lpeInt16_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt16(Left)^) xor Int64(PInt64(Right)^); end;
+procedure lpeInt16_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt16(Left)^ xor PVariant(Right)^; end;
+procedure lpeUInt32_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ xor PUInt8(Right)^; end;
+procedure lpeUInt32_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) xor Int64(PInt8(Right)^); end;
+procedure lpeUInt32_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ xor PUInt16(Right)^; end;
+procedure lpeUInt32_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) xor Int64(PInt16(Right)^); end;
+procedure lpeUInt32_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt32(Dest)^ := PUInt32(Left)^ xor PUInt32(Right)^; end;
+procedure lpeUInt32_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) xor Int64(PInt32(Right)^); end;
+procedure lpeUInt32_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PUInt32(Left)^) xor UInt64(PUInt64(Right)^); end;
+procedure lpeUInt32_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt32(Left)^) xor Int64(PInt64(Right)^); end;
+procedure lpeUInt32_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt32(Left)^ xor PVariant(Right)^; end;
+procedure lpeInt32_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ xor PUInt8(Right)^; end;
+procedure lpeInt32_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ xor PInt8(Right)^; end;
+procedure lpeInt32_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ xor PUInt16(Right)^; end;
+procedure lpeInt32_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ xor PInt16(Right)^; end;
+procedure lpeInt32_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) xor Int64(PUInt32(Right)^); end;
+procedure lpeInt32_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := PInt32(Left)^ xor PInt32(Right)^; end;
+procedure lpeInt32_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := UInt64(PInt32(Left)^) xor UInt64(PUInt64(Right)^); end;
+procedure lpeInt32_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PInt32(Left)^) xor Int64(PInt64(Right)^); end;
+procedure lpeInt32_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt32(Left)^ xor PVariant(Right)^; end;
+procedure lpeUInt64_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ xor PUInt8(Right)^; end;
+procedure lpeUInt64_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ xor PInt8(Right)^; end;
+procedure lpeUInt64_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ xor PUInt16(Right)^; end;
+procedure lpeUInt64_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ xor PInt16(Right)^; end;
+procedure lpeUInt64_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ xor PUInt32(Right)^; end;
+procedure lpeUInt64_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ xor PInt32(Right)^; end;
+procedure lpeUInt64_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := PUInt64(Left)^ xor PUInt64(Right)^; end;
+procedure lpeUInt64_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := Int64(PUInt64(Left)^) xor Int64(PInt64(Right)^); end;
+procedure lpeUInt64_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUInt64(Left)^ xor PVariant(Right)^; end;
+procedure lpeInt64_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ xor PUInt8(Right)^; end;
+procedure lpeInt64_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ xor PInt8(Right)^; end;
+procedure lpeInt64_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ xor PUInt16(Right)^; end;
+procedure lpeInt64_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ xor PInt16(Right)^; end;
+procedure lpeInt64_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ xor PUInt32(Right)^; end;
+procedure lpeInt64_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ xor PInt32(Right)^; end;
+procedure lpeInt64_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ xor PUInt64(Right)^; end;
+procedure lpeInt64_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := PInt64(Left)^ xor PInt64(Right)^; end;
+procedure lpeInt64_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PInt64(Left)^ xor PVariant(Right)^; end;
+procedure lpeVariant_XOR_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PUInt8(Right)^; end;
+procedure lpeVariant_XOR_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PInt8(Right)^; end;
+procedure lpeVariant_XOR_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PUInt16(Right)^; end;
+procedure lpeVariant_XOR_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PInt16(Right)^; end;
+procedure lpeVariant_XOR_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PUInt32(Right)^; end;
+procedure lpeVariant_XOR_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PInt32(Right)^; end;
+procedure lpeVariant_XOR_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PUInt64(Right)^; end;
+procedure lpeVariant_XOR_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PInt64(Right)^; end;
+procedure lpeVariant_XOR_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PVariant(Left)^ xor PVariant(Right)^; end;
+procedure lpeUInt8_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := -PUInt8(Left)^; end;
+procedure lpeInt8_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := -PInt8(Left)^; end;
+procedure lpeUInt16_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := -PUInt16(Left)^; end;
+procedure lpeInt16_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := -PInt16(Left)^; end;
+procedure lpeUInt32_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := -PUInt32(Left)^; end;
+procedure lpeInt32_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt32(Dest)^ := -PInt32(Left)^; end;
+procedure lpeUInt64_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PUInt64(Dest)^ := -PUInt64(Left)^; end;
+procedure lpeInt64_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PInt64(Dest)^ := -PInt64(Left)^; end;
+procedure lpeSingle_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PSingle(Dest)^ := -PSingle(Left)^; end;
+procedure lpeDouble_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PDouble(Dest)^ := -PDouble(Left)^; end;
+procedure lpeCurrency_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PCurrency(Dest)^ := -PCurrency(Left)^; end;
+procedure lpeExtended_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PExtended(Dest)^ := -PExtended(Left)^; end;
+procedure lpeVariant_UMIN(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := -PVariant(Left)^; end;
 
 //Variant
-procedure lpeVariant_ASGN_Boolean(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PBoolean(Left)^; end;
-procedure lpeVariant_ASGN_WBool(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PWordBool(Left)^; end;
-procedure lpeVariant_ASGN_LBool(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PLongBool(Left)^; end;
-procedure lpeVariant_ASGN_AChar(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PAnsiChar(Left)^; end;
-procedure lpeVariant_ASGN_WChar(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PWideChar(Left)^; end;
-procedure lpeVariant_ASGN_SString(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PShortString(Left)^; end;
-procedure lpeVariant_ASGN_AString(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PAnsiString(Left)^; end;
-procedure lpeVariant_ASGN_WString(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PWideString(Left)^; end;
-procedure lpeVariant_ASGN_UString(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUnicodeString(Left)^; end;
+procedure lpeVariant_ASGN_Boolean(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PBoolean(Left)^; end;
+procedure lpeVariant_ASGN_WBool(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PWordBool(Left)^; end;
+procedure lpeVariant_ASGN_LBool(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PLongBool(Left)^; end;
+procedure lpeVariant_ASGN_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PAnsiChar(Left)^; end;
+procedure lpeVariant_ASGN_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PWideChar(Left)^; end;
+procedure lpeVariant_ASGN_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PShortString(Left)^; end;
+procedure lpeVariant_ASGN_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PAnsiString(Left)^; end;
+procedure lpeVariant_ASGN_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PWideString(Left)^; end;
+procedure lpeVariant_ASGN_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUnicodeString(Left)^; end;
 
 //Boolean
-procedure lpeBoolean_NOT(const Dest, Left, Right: Pointer); begin PBoolean(Dest)^ := not PBoolean(Left)^; end;
-procedure lpeWBool_NOT(const Dest, Left, Right: Pointer); begin if PWordBool(Left)^ then PUInt16(Dest)^ := Ord(False) else PUInt16(Dest)^ := Ord(True); end;
-procedure lpeLBool_NOT(const Dest, Left, Right: Pointer); begin if PLongBool(Left)^ then PUInt32(Dest)^ := Ord(False) else PUInt32(Dest)^ := Ord(True); end;
+procedure lpeBoolean_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin PBoolean(Dest)^ := not PBoolean(Left)^; end;
+procedure lpeWBool_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin if PWordBool(Left)^ then PUInt16(Dest)^ := Ord(False) else PUInt16(Dest)^ := Ord(True); end;
+procedure lpeLBool_NOT(const Dest, Left, Right: Pointer);  lape_extdecl begin if PLongBool(Left)^ then PUInt32(Dest)^ := Ord(False) else PUInt32(Dest)^ := Ord(True); end;
 
-procedure lpeBoolean_ASGN_Variant(const Dest, Left, Right: Pointer); begin PBoolean(Dest)^ := PVariant(Left)^; end;
-procedure lpeWBool_ASGN_Variant(const Dest, Left, Right: Pointer); begin PWordBool(Dest)^ := PVariant(Left)^; end;
-procedure lpeLBool_ASGN_Variant(const Dest, Left, Right: Pointer); begin PLongBool(Dest)^ := PVariant(Left)^; end;
+procedure lpeBoolean_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PBoolean(Dest)^ := PVariant(Left)^; end;
+procedure lpeWBool_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PWordBool(Dest)^ := PVariant(Left)^; end;
+procedure lpeLBool_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PLongBool(Dest)^ := PVariant(Left)^; end;
 
 //string + char
 //ShortString
-procedure lpeSString_EQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ = PShortString(Right)^; end;
-procedure lpeSString_EQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ = PAnsiString(Right)^; end;
-procedure lpeSString_EQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ = PWideString(Right)^; end;
-procedure lpeSString_EQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ = PUnicodeString(Right)^; end;
-procedure lpeSString_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ = PVariant(Right)^; end;
-procedure lpeSString_EQ_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ = PAnsiChar(Right)^; end;
-procedure lpeSString_EQ_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ = PWideChar(Right)^; end;
-procedure lpeSString_GT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ > PShortString(Right)^; end;
-procedure lpeSString_GT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ > PAnsiString(Right)^; end;
-procedure lpeSString_GT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ > PWideString(Right)^; end;
-procedure lpeSString_GT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ > PUnicodeString(Right)^; end;
-procedure lpeSString_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ > PVariant(Right)^; end;
-procedure lpeSString_GT_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ > PAnsiChar(Right)^; end;
-procedure lpeSString_GT_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ > PWideChar(Right)^; end;
-procedure lpeSString_GTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ >= PShortString(Right)^; end;
-procedure lpeSString_GTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ >= PAnsiString(Right)^; end;
-procedure lpeSString_GTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ >= PWideString(Right)^; end;
-procedure lpeSString_GTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ >= PUnicodeString(Right)^; end;
-procedure lpeSString_GTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ >= PVariant(Right)^; end;
-procedure lpeSString_GTE_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ >= PAnsiChar(Right)^; end;
-procedure lpeSString_GTE_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ >= PWideChar(Right)^; end;
-procedure lpeSString_LT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ < PShortString(Right)^; end;
-procedure lpeSString_LT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ < PAnsiString(Right)^; end;
-procedure lpeSString_LT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ < PWideString(Right)^; end;
-procedure lpeSString_LT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ < PUnicodeString(Right)^; end;
-procedure lpeSString_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ < PVariant(Right)^; end;
-procedure lpeSString_LT_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ < PAnsiChar(Right)^; end;
-procedure lpeSString_LT_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ < PWideChar(Right)^; end;
-procedure lpeSString_LTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <= PShortString(Right)^; end;
-procedure lpeSString_LTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <= PAnsiString(Right)^; end;
-procedure lpeSString_LTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <= PWideString(Right)^; end;
-procedure lpeSString_LTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <= PUnicodeString(Right)^; end;
-procedure lpeSString_LTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <= PVariant(Right)^; end;
-procedure lpeSString_LTE_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <= PAnsiChar(Right)^; end;
-procedure lpeSString_LTE_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <= PWideChar(Right)^; end;
-procedure lpeSString_NEQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <> PShortString(Right)^; end;
-procedure lpeSString_NEQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <> PAnsiString(Right)^; end;
-procedure lpeSString_NEQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <> PWideString(Right)^; end;
-procedure lpeSString_NEQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <> PUnicodeString(Right)^; end;
-procedure lpeSString_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <> PVariant(Right)^; end;
-procedure lpeSString_NEQ_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <> PAnsiChar(Right)^; end;
-procedure lpeSString_NEQ_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PShortString(Left)^ <> PWideChar(Right)^; end;
+procedure lpeSString_EQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ = PShortString(Right)^; end;
+procedure lpeSString_EQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ = PAnsiString(Right)^; end;
+procedure lpeSString_EQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ = PWideString(Right)^; end;
+procedure lpeSString_EQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ = PUnicodeString(Right)^; end;
+procedure lpeSString_EQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ = PVariant(Right)^; end;
+procedure lpeSString_EQ_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ = PAnsiChar(Right)^; end;
+procedure lpeSString_EQ_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ = PWideChar(Right)^; end;
+procedure lpeSString_GT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ > PShortString(Right)^; end;
+procedure lpeSString_GT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ > PAnsiString(Right)^; end;
+procedure lpeSString_GT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ > PWideString(Right)^; end;
+procedure lpeSString_GT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ > PUnicodeString(Right)^; end;
+procedure lpeSString_GT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ > PVariant(Right)^; end;
+procedure lpeSString_GT_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ > PAnsiChar(Right)^; end;
+procedure lpeSString_GT_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ > PWideChar(Right)^; end;
+procedure lpeSString_GTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ >= PShortString(Right)^; end;
+procedure lpeSString_GTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ >= PAnsiString(Right)^; end;
+procedure lpeSString_GTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ >= PWideString(Right)^; end;
+procedure lpeSString_GTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ >= PUnicodeString(Right)^; end;
+procedure lpeSString_GTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ >= PVariant(Right)^; end;
+procedure lpeSString_GTE_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ >= PAnsiChar(Right)^; end;
+procedure lpeSString_GTE_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ >= PWideChar(Right)^; end;
+procedure lpeSString_LT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ < PShortString(Right)^; end;
+procedure lpeSString_LT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ < PAnsiString(Right)^; end;
+procedure lpeSString_LT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ < PWideString(Right)^; end;
+procedure lpeSString_LT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ < PUnicodeString(Right)^; end;
+procedure lpeSString_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ < PVariant(Right)^; end;
+procedure lpeSString_LT_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ < PAnsiChar(Right)^; end;
+procedure lpeSString_LT_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ < PWideChar(Right)^; end;
+procedure lpeSString_LTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <= PShortString(Right)^; end;
+procedure lpeSString_LTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <= PAnsiString(Right)^; end;
+procedure lpeSString_LTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <= PWideString(Right)^; end;
+procedure lpeSString_LTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <= PUnicodeString(Right)^; end;
+procedure lpeSString_LTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <= PVariant(Right)^; end;
+procedure lpeSString_LTE_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <= PAnsiChar(Right)^; end;
+procedure lpeSString_LTE_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <= PWideChar(Right)^; end;
+procedure lpeSString_NEQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <> PShortString(Right)^; end;
+procedure lpeSString_NEQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <> PAnsiString(Right)^; end;
+procedure lpeSString_NEQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <> PWideString(Right)^; end;
+procedure lpeSString_NEQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <> PUnicodeString(Right)^; end;
+procedure lpeSString_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <> PVariant(Right)^; end;
+procedure lpeSString_NEQ_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <> PAnsiChar(Right)^; end;
+procedure lpeSString_NEQ_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PShortString(Left)^ <> PWideChar(Right)^; end;
 
-procedure lpeSString_ASGN_SString_UInt8(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := Copy(PShortString(Left)^, 1, PUInt8(Right)^); end;
-procedure lpeSString_ASGN_SString(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := PShortString(Left)^; end;
-procedure lpeSString_ASGN_AString(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := PAnsiString(Left)^; end;
-procedure lpeSString_ASGN_WString(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := PWideString(Left)^; end;
-procedure lpeSString_ASGN_UString(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := PUnicodeString(Left)^; end;
-procedure lpeSString_ASGN_Variant(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := PVariant(Left)^; end;
-procedure lpeSString_ASGN_AChar(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := PAnsiChar(Left)^; end;
-procedure lpeSString_ASGN_WChar(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := PWideChar(Left)^; end;
-procedure lpeSString_ADD_SString(const Dest, Left, Right: Pointer); begin PShortString(Dest)^ := PShortString(Left)^ + PShortString(Right)^; end;
-procedure lpeSString_ADD_AString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PShortString(Left)^ + PAnsiString(Right)^; end;
-procedure lpeSString_ADD_WString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PShortString(Left)^ + PWideString(Right)^; end;
-procedure lpeSString_ADD_UString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PShortString(Left)^ + PUnicodeString(Right)^; end;
-procedure lpeSString_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PShortString(Left)^ + PVariant(Right)^; end;
-procedure lpeSString_ADD_AChar(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PShortString(Left)^ + PAnsiChar(Right)^; end;
-procedure lpeSString_ADD_WChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PShortString(Left)^ + PWideChar(Right)^; end;
+procedure lpeSString_ASGN_SString_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := Copy(PShortString(Left)^, 1, PUInt8(Right)^); end;
+procedure lpeSString_ASGN_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := PShortString(Left)^; end;
+procedure lpeSString_ASGN_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := PAnsiString(Left)^; end;
+procedure lpeSString_ASGN_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := PWideString(Left)^; end;
+procedure lpeSString_ASGN_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := PUnicodeString(Left)^; end;
+procedure lpeSString_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := PVariant(Left)^; end;
+procedure lpeSString_ASGN_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := PAnsiChar(Left)^; end;
+procedure lpeSString_ASGN_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := PWideChar(Left)^; end;
+procedure lpeSString_ADD_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PShortString(Dest)^ := PShortString(Left)^ + PShortString(Right)^; end;
+procedure lpeSString_ADD_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PShortString(Left)^ + PAnsiString(Right)^; end;
+procedure lpeSString_ADD_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PShortString(Left)^ + PWideString(Right)^; end;
+procedure lpeSString_ADD_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PShortString(Left)^ + PUnicodeString(Right)^; end;
+procedure lpeSString_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PShortString(Left)^ + PVariant(Right)^; end;
+procedure lpeSString_ADD_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PShortString(Left)^ + PAnsiChar(Right)^; end;
+procedure lpeSString_ADD_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PShortString(Left)^ + PWideChar(Right)^; end;
 
 //AnsiString
-procedure lpeAString_EQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PShortString(Right)^; end;
-procedure lpeAString_EQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PAnsiString(Right)^; end;
-procedure lpeAString_EQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PWideString(Right)^; end;
-procedure lpeAString_EQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PUnicodeString(Right)^; end;
-procedure lpeAString_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PVariant(Right)^; end;
-procedure lpeAString_EQ_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PAnsiChar(Right)^; end;
-procedure lpeAString_EQ_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PWideChar(Right)^; end;
-procedure lpeAString_GT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PShortString(Right)^; end;
-procedure lpeAString_GT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PAnsiString(Right)^; end;
-procedure lpeAString_GT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PWideString(Right)^; end;
-procedure lpeAString_GT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PUnicodeString(Right)^; end;
-procedure lpeAString_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PVariant(Right)^; end;
-procedure lpeAString_GT_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PAnsiChar(Right)^; end;
-procedure lpeAString_GT_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PWideChar(Right)^; end;
-procedure lpeAString_GTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PShortString(Right)^; end;
-procedure lpeAString_GTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PAnsiString(Right)^; end;
-procedure lpeAString_GTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PWideString(Right)^; end;
-procedure lpeAString_GTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PUnicodeString(Right)^; end;
-procedure lpeAString_GTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PVariant(Right)^; end;
-procedure lpeAString_GTE_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PAnsiChar(Right)^; end;
-procedure lpeAString_GTE_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PWideChar(Right)^; end;
-procedure lpeAString_LT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PShortString(Right)^; end;
-procedure lpeAString_LT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PAnsiString(Right)^; end;
-procedure lpeAString_LT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PWideString(Right)^; end;
-procedure lpeAString_LT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PUnicodeString(Right)^; end;
-procedure lpeAString_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PVariant(Right)^; end;
-procedure lpeAString_LT_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PAnsiChar(Right)^; end;
-procedure lpeAString_LT_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PWideChar(Right)^; end;
-procedure lpeAString_LTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PShortString(Right)^; end;
-procedure lpeAString_LTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PAnsiString(Right)^; end;
-procedure lpeAString_LTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PWideString(Right)^; end;
-procedure lpeAString_LTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PUnicodeString(Right)^; end;
-procedure lpeAString_LTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PVariant(Right)^; end;
-procedure lpeAString_LTE_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PAnsiChar(Right)^; end;
-procedure lpeAString_LTE_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PWideChar(Right)^; end;
-procedure lpeAString_NEQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PShortString(Right)^; end;
-procedure lpeAString_NEQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PAnsiString(Right)^; end;
-procedure lpeAString_NEQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PWideString(Right)^; end;
-procedure lpeAString_NEQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PUnicodeString(Right)^; end;
-procedure lpeAString_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PVariant(Right)^; end;
-procedure lpeAString_NEQ_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PAnsiChar(Right)^; end;
-procedure lpeAString_NEQ_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PWideChar(Right)^; end;
+procedure lpeAString_EQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PShortString(Right)^; end;
+procedure lpeAString_EQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PAnsiString(Right)^; end;
+procedure lpeAString_EQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PWideString(Right)^; end;
+procedure lpeAString_EQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PUnicodeString(Right)^; end;
+procedure lpeAString_EQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PVariant(Right)^; end;
+procedure lpeAString_EQ_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PAnsiChar(Right)^; end;
+procedure lpeAString_EQ_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ = PWideChar(Right)^; end;
+procedure lpeAString_GT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PShortString(Right)^; end;
+procedure lpeAString_GT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PAnsiString(Right)^; end;
+procedure lpeAString_GT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PWideString(Right)^; end;
+procedure lpeAString_GT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PUnicodeString(Right)^; end;
+procedure lpeAString_GT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PVariant(Right)^; end;
+procedure lpeAString_GT_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PAnsiChar(Right)^; end;
+procedure lpeAString_GT_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ > PWideChar(Right)^; end;
+procedure lpeAString_GTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PShortString(Right)^; end;
+procedure lpeAString_GTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PAnsiString(Right)^; end;
+procedure lpeAString_GTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PWideString(Right)^; end;
+procedure lpeAString_GTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PUnicodeString(Right)^; end;
+procedure lpeAString_GTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PVariant(Right)^; end;
+procedure lpeAString_GTE_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PAnsiChar(Right)^; end;
+procedure lpeAString_GTE_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ >= PWideChar(Right)^; end;
+procedure lpeAString_LT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PShortString(Right)^; end;
+procedure lpeAString_LT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PAnsiString(Right)^; end;
+procedure lpeAString_LT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PWideString(Right)^; end;
+procedure lpeAString_LT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PUnicodeString(Right)^; end;
+procedure lpeAString_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PVariant(Right)^; end;
+procedure lpeAString_LT_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PAnsiChar(Right)^; end;
+procedure lpeAString_LT_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ < PWideChar(Right)^; end;
+procedure lpeAString_LTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PShortString(Right)^; end;
+procedure lpeAString_LTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PAnsiString(Right)^; end;
+procedure lpeAString_LTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PWideString(Right)^; end;
+procedure lpeAString_LTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PUnicodeString(Right)^; end;
+procedure lpeAString_LTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PVariant(Right)^; end;
+procedure lpeAString_LTE_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PAnsiChar(Right)^; end;
+procedure lpeAString_LTE_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <= PWideChar(Right)^; end;
+procedure lpeAString_NEQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PShortString(Right)^; end;
+procedure lpeAString_NEQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PAnsiString(Right)^; end;
+procedure lpeAString_NEQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PWideString(Right)^; end;
+procedure lpeAString_NEQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PUnicodeString(Right)^; end;
+procedure lpeAString_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PVariant(Right)^; end;
+procedure lpeAString_NEQ_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PAnsiChar(Right)^; end;
+procedure lpeAString_NEQ_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiString(Left)^ <> PWideChar(Right)^; end;
 
-procedure lpeAString_ASGN_SString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PShortString(Left)^; end;
-procedure lpeAString_ASGN_AString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PAnsiString(Left)^; end;
-procedure lpeAString_ASGN_WString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PWideString(Left)^; end;
-procedure lpeAString_ASGN_UString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PUnicodeString(Left)^; end;
-procedure lpeAString_ASGN_Variant(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PVariant(Left)^; end;
-procedure lpeAString_ASGN_AChar(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PAnsiChar(Left)^; end;
-procedure lpeAString_ASGN_WChar(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PWideChar(Left)^; end;
-procedure lpeAString_ADD_SString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PAnsiString(Left)^ + PShortString(Right)^; end;
-procedure lpeAString_ADD_AString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PAnsiString(Left)^ + PAnsiString(Right)^; end;
-procedure lpeAString_ADD_WString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PAnsiString(Left)^ + PWideString(Right)^; end;
-procedure lpeAString_ADD_UString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PAnsiString(Left)^ + PUnicodeString(Right)^; end;
-procedure lpeAString_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PAnsiString(Left)^ + PVariant(Right)^; end;
-procedure lpeAString_ADD_AChar(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PAnsiString(Left)^ + PAnsiChar(Right)^; end;
-procedure lpeAString_ADD_WChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PAnsiString(Left)^ + PWideChar(Right)^; end;
+procedure lpeAString_ASGN_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PShortString(Left)^; end;
+procedure lpeAString_ASGN_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PAnsiString(Left)^; end;
+procedure lpeAString_ASGN_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PWideString(Left)^; end;
+procedure lpeAString_ASGN_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PUnicodeString(Left)^; end;
+procedure lpeAString_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PVariant(Left)^; end;
+procedure lpeAString_ASGN_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PAnsiChar(Left)^; end;
+procedure lpeAString_ASGN_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PWideChar(Left)^; end;
+procedure lpeAString_ADD_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PAnsiString(Left)^ + PShortString(Right)^; end;
+procedure lpeAString_ADD_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PAnsiString(Left)^ + PAnsiString(Right)^; end;
+procedure lpeAString_ADD_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PAnsiString(Left)^ + PWideString(Right)^; end;
+procedure lpeAString_ADD_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PAnsiString(Left)^ + PUnicodeString(Right)^; end;
+procedure lpeAString_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PAnsiString(Left)^ + PVariant(Right)^; end;
+procedure lpeAString_ADD_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PAnsiString(Left)^ + PAnsiChar(Right)^; end;
+procedure lpeAString_ADD_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PAnsiString(Left)^ + PWideChar(Right)^; end;
 
 //WideString
-procedure lpeWString_EQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ = PShortString(Right)^; end;
-procedure lpeWString_EQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ = PAnsiString(Right)^; end;
-procedure lpeWString_EQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ = PWideString(Right)^; end;
-procedure lpeWString_EQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ = PUnicodeString(Right)^; end;
-procedure lpeWString_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ = PVariant(Right)^; end;
-procedure lpeWString_EQ_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ = PAnsiChar(Right)^; end;
-procedure lpeWString_EQ_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ = PWideChar(Right)^; end;
-procedure lpeWString_GT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ > PShortString(Right)^; end;
-procedure lpeWString_GT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ > PAnsiString(Right)^; end;
-procedure lpeWString_GT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ > PWideString(Right)^; end;
-procedure lpeWString_GT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ > PUnicodeString(Right)^; end;
-procedure lpeWString_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ > PVariant(Right)^; end;
-procedure lpeWString_GT_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ > PAnsiChar(Right)^; end;
-procedure lpeWString_GT_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ > PWideChar(Right)^; end;
-procedure lpeWString_GTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ >= PShortString(Right)^; end;
-procedure lpeWString_GTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ >= PAnsiString(Right)^; end;
-procedure lpeWString_GTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ >= PWideString(Right)^; end;
-procedure lpeWString_GTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ >= PUnicodeString(Right)^; end;
-procedure lpeWString_GTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ >= PVariant(Right)^; end;
-procedure lpeWString_GTE_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ >= PAnsiChar(Right)^; end;
-procedure lpeWString_GTE_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ >= PWideChar(Right)^; end;
-procedure lpeWString_LT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ < PShortString(Right)^; end;
-procedure lpeWString_LT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ < PAnsiString(Right)^; end;
-procedure lpeWString_LT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ < PWideString(Right)^; end;
-procedure lpeWString_LT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ < PUnicodeString(Right)^; end;
-procedure lpeWString_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ < PVariant(Right)^; end;
-procedure lpeWString_LT_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ < PAnsiChar(Right)^; end;
-procedure lpeWString_LT_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ < PWideChar(Right)^; end;
-procedure lpeWString_LTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <= PShortString(Right)^; end;
-procedure lpeWString_LTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <= PAnsiString(Right)^; end;
-procedure lpeWString_LTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <= PWideString(Right)^; end;
-procedure lpeWString_LTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <= PUnicodeString(Right)^; end;
-procedure lpeWString_LTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <= PVariant(Right)^; end;
-procedure lpeWString_LTE_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <= PAnsiChar(Right)^; end;
-procedure lpeWString_LTE_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <= PWideChar(Right)^; end;
-procedure lpeWString_NEQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <> PShortString(Right)^; end;
-procedure lpeWString_NEQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <> PAnsiString(Right)^; end;
-procedure lpeWString_NEQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <> PWideString(Right)^; end;
-procedure lpeWString_NEQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <> PUnicodeString(Right)^; end;
-procedure lpeWString_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <> PVariant(Right)^; end;
-procedure lpeWString_NEQ_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <> PAnsiChar(Right)^; end;
-procedure lpeWString_NEQ_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideString(Left)^ <> PWideChar(Right)^; end;
+procedure lpeWString_EQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ = PShortString(Right)^; end;
+procedure lpeWString_EQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ = PAnsiString(Right)^; end;
+procedure lpeWString_EQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ = PWideString(Right)^; end;
+procedure lpeWString_EQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ = PUnicodeString(Right)^; end;
+procedure lpeWString_EQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ = PVariant(Right)^; end;
+procedure lpeWString_EQ_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ = PAnsiChar(Right)^; end;
+procedure lpeWString_EQ_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ = PWideChar(Right)^; end;
+procedure lpeWString_GT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ > PShortString(Right)^; end;
+procedure lpeWString_GT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ > PAnsiString(Right)^; end;
+procedure lpeWString_GT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ > PWideString(Right)^; end;
+procedure lpeWString_GT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ > PUnicodeString(Right)^; end;
+procedure lpeWString_GT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ > PVariant(Right)^; end;
+procedure lpeWString_GT_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ > PAnsiChar(Right)^; end;
+procedure lpeWString_GT_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ > PWideChar(Right)^; end;
+procedure lpeWString_GTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ >= PShortString(Right)^; end;
+procedure lpeWString_GTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ >= PAnsiString(Right)^; end;
+procedure lpeWString_GTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ >= PWideString(Right)^; end;
+procedure lpeWString_GTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ >= PUnicodeString(Right)^; end;
+procedure lpeWString_GTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ >= PVariant(Right)^; end;
+procedure lpeWString_GTE_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ >= PAnsiChar(Right)^; end;
+procedure lpeWString_GTE_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ >= PWideChar(Right)^; end;
+procedure lpeWString_LT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ < PShortString(Right)^; end;
+procedure lpeWString_LT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ < PAnsiString(Right)^; end;
+procedure lpeWString_LT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ < PWideString(Right)^; end;
+procedure lpeWString_LT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ < PUnicodeString(Right)^; end;
+procedure lpeWString_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ < PVariant(Right)^; end;
+procedure lpeWString_LT_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ < PAnsiChar(Right)^; end;
+procedure lpeWString_LT_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ < PWideChar(Right)^; end;
+procedure lpeWString_LTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <= PShortString(Right)^; end;
+procedure lpeWString_LTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <= PAnsiString(Right)^; end;
+procedure lpeWString_LTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <= PWideString(Right)^; end;
+procedure lpeWString_LTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <= PUnicodeString(Right)^; end;
+procedure lpeWString_LTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <= PVariant(Right)^; end;
+procedure lpeWString_LTE_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <= PAnsiChar(Right)^; end;
+procedure lpeWString_LTE_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <= PWideChar(Right)^; end;
+procedure lpeWString_NEQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <> PShortString(Right)^; end;
+procedure lpeWString_NEQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <> PAnsiString(Right)^; end;
+procedure lpeWString_NEQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <> PWideString(Right)^; end;
+procedure lpeWString_NEQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <> PUnicodeString(Right)^; end;
+procedure lpeWString_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <> PVariant(Right)^; end;
+procedure lpeWString_NEQ_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <> PAnsiChar(Right)^; end;
+procedure lpeWString_NEQ_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideString(Left)^ <> PWideChar(Right)^; end;
 
-procedure lpeWString_ASGN_SString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PShortString(Left)^; end;
-procedure lpeWString_ASGN_AString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PAnsiString(Left)^; end;
-procedure lpeWString_ASGN_WString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideString(Left)^; end;
-procedure lpeWString_ASGN_UString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PUnicodeString(Left)^; end;
-procedure lpeWString_ASGN_Variant(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PVariant(Left)^; end;
-procedure lpeWString_ASGN_WChar(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideChar(Left)^; end;
-procedure lpeWString_ASGN_AChar(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PAnsiChar(Left)^; end;
-procedure lpeWString_ADD_SString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideString(Left)^ + PShortString(Right)^; end;
-procedure lpeWString_ADD_AString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideString(Left)^ + PAnsiString(Right)^; end;
-procedure lpeWString_ADD_WString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideString(Left)^ + PWideString(Right)^; end;
-procedure lpeWString_ADD_UString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideString(Left)^ + PUnicodeString(Right)^; end;
-procedure lpeWString_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PWideString(Left)^ + PVariant(Right)^; end;
-procedure lpeWString_ADD_WChar(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideString(Left)^ + PWideChar(Right)^; end;
-procedure lpeWString_ADD_AChar(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideString(Left)^ + PAnsiChar(Right)^; end;
+procedure lpeWString_ASGN_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PShortString(Left)^; end;
+procedure lpeWString_ASGN_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PAnsiString(Left)^; end;
+procedure lpeWString_ASGN_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideString(Left)^; end;
+procedure lpeWString_ASGN_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PUnicodeString(Left)^; end;
+procedure lpeWString_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PVariant(Left)^; end;
+procedure lpeWString_ASGN_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideChar(Left)^; end;
+procedure lpeWString_ASGN_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PAnsiChar(Left)^; end;
+procedure lpeWString_ADD_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideString(Left)^ + PShortString(Right)^; end;
+procedure lpeWString_ADD_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideString(Left)^ + PAnsiString(Right)^; end;
+procedure lpeWString_ADD_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideString(Left)^ + PWideString(Right)^; end;
+procedure lpeWString_ADD_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideString(Left)^ + PUnicodeString(Right)^; end;
+procedure lpeWString_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PWideString(Left)^ + PVariant(Right)^; end;
+procedure lpeWString_ADD_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideString(Left)^ + PWideChar(Right)^; end;
+procedure lpeWString_ADD_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideString(Left)^ + PAnsiChar(Right)^; end;
 
 //UnicodeString
-procedure lpeUString_EQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PShortString(Right)^; end;
-procedure lpeUString_EQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PAnsiString(Right)^; end;
-procedure lpeUString_EQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PWideString(Right)^; end;
-procedure lpeUString_EQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PUnicodeString(Right)^; end;
-procedure lpeUString_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PVariant(Right)^; end;
-procedure lpeUString_EQ_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PAnsiChar(Right)^; end;
-procedure lpeUString_EQ_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PWideChar(Right)^; end;
-procedure lpeUString_GT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PShortString(Right)^; end;
-procedure lpeUString_GT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PAnsiString(Right)^; end;
-procedure lpeUString_GT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PWideString(Right)^; end;
-procedure lpeUString_GT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PUnicodeString(Right)^; end;
-procedure lpeUString_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PVariant(Right)^; end;
-procedure lpeUString_GT_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PAnsiChar(Right)^; end;
-procedure lpeUString_GT_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PWideChar(Right)^; end;
-procedure lpeUString_GTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PShortString(Right)^; end;
-procedure lpeUString_GTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PAnsiString(Right)^; end;
-procedure lpeUString_GTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PWideString(Right)^; end;
-procedure lpeUString_GTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PUnicodeString(Right)^; end;
-procedure lpeUString_GTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PVariant(Right)^; end;
-procedure lpeUString_GTE_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PAnsiChar(Right)^; end;
-procedure lpeUString_GTE_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PWideChar(Right)^; end;
-procedure lpeUString_LT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PShortString(Right)^; end;
-procedure lpeUString_LT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PAnsiString(Right)^; end;
-procedure lpeUString_LT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PWideString(Right)^; end;
-procedure lpeUString_LT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PUnicodeString(Right)^; end;
-procedure lpeUString_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PVariant(Right)^; end;
-procedure lpeUString_LT_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PAnsiChar(Right)^; end;
-procedure lpeUString_LT_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PWideChar(Right)^; end;
-procedure lpeUString_LTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PShortString(Right)^; end;
-procedure lpeUString_LTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PAnsiString(Right)^; end;
-procedure lpeUString_LTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PWideString(Right)^; end;
-procedure lpeUString_LTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PUnicodeString(Right)^; end;
-procedure lpeUString_LTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PVariant(Right)^; end;
-procedure lpeUString_LTE_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PAnsiChar(Right)^; end;
-procedure lpeUString_LTE_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PWideChar(Right)^; end;
-procedure lpeUString_NEQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PShortString(Right)^; end;
-procedure lpeUString_NEQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PAnsiString(Right)^; end;
-procedure lpeUString_NEQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PWideString(Right)^; end;
-procedure lpeUString_NEQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PUnicodeString(Right)^; end;
-procedure lpeUString_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PVariant(Right)^; end;
-procedure lpeUString_NEQ_AChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PAnsiChar(Right)^; end;
-procedure lpeUString_NEQ_WChar(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PWideChar(Right)^; end;
+procedure lpeUString_EQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PShortString(Right)^; end;
+procedure lpeUString_EQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PAnsiString(Right)^; end;
+procedure lpeUString_EQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PWideString(Right)^; end;
+procedure lpeUString_EQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PUnicodeString(Right)^; end;
+procedure lpeUString_EQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PVariant(Right)^; end;
+procedure lpeUString_EQ_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PAnsiChar(Right)^; end;
+procedure lpeUString_EQ_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ = PWideChar(Right)^; end;
+procedure lpeUString_GT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PShortString(Right)^; end;
+procedure lpeUString_GT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PAnsiString(Right)^; end;
+procedure lpeUString_GT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PWideString(Right)^; end;
+procedure lpeUString_GT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PUnicodeString(Right)^; end;
+procedure lpeUString_GT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PVariant(Right)^; end;
+procedure lpeUString_GT_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PAnsiChar(Right)^; end;
+procedure lpeUString_GT_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ > PWideChar(Right)^; end;
+procedure lpeUString_GTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PShortString(Right)^; end;
+procedure lpeUString_GTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PAnsiString(Right)^; end;
+procedure lpeUString_GTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PWideString(Right)^; end;
+procedure lpeUString_GTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PUnicodeString(Right)^; end;
+procedure lpeUString_GTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PVariant(Right)^; end;
+procedure lpeUString_GTE_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PAnsiChar(Right)^; end;
+procedure lpeUString_GTE_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ >= PWideChar(Right)^; end;
+procedure lpeUString_LT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PShortString(Right)^; end;
+procedure lpeUString_LT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PAnsiString(Right)^; end;
+procedure lpeUString_LT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PWideString(Right)^; end;
+procedure lpeUString_LT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PUnicodeString(Right)^; end;
+procedure lpeUString_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PVariant(Right)^; end;
+procedure lpeUString_LT_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PAnsiChar(Right)^; end;
+procedure lpeUString_LT_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ < PWideChar(Right)^; end;
+procedure lpeUString_LTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PShortString(Right)^; end;
+procedure lpeUString_LTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PAnsiString(Right)^; end;
+procedure lpeUString_LTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PWideString(Right)^; end;
+procedure lpeUString_LTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PUnicodeString(Right)^; end;
+procedure lpeUString_LTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PVariant(Right)^; end;
+procedure lpeUString_LTE_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PAnsiChar(Right)^; end;
+procedure lpeUString_LTE_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <= PWideChar(Right)^; end;
+procedure lpeUString_NEQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PShortString(Right)^; end;
+procedure lpeUString_NEQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PAnsiString(Right)^; end;
+procedure lpeUString_NEQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PWideString(Right)^; end;
+procedure lpeUString_NEQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PUnicodeString(Right)^; end;
+procedure lpeUString_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PVariant(Right)^; end;
+procedure lpeUString_NEQ_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PAnsiChar(Right)^; end;
+procedure lpeUString_NEQ_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PUnicodeString(Left)^ <> PWideChar(Right)^; end;
 
-procedure lpeUString_ASGN_SString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PShortString(Left)^; end;
-procedure lpeUString_ASGN_AString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PAnsiString(Left)^; end;
-procedure lpeUString_ASGN_WString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PWideString(Left)^; end;
-procedure lpeUString_ASGN_UString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PUnicodeString(Left)^; end;
-procedure lpeUString_ASGN_Variant(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PVariant(Left)^; end;
-procedure lpeUString_ASGN_WChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PWideChar(Left)^; end;
-procedure lpeUString_ASGN_AChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PAnsiChar(Left)^; end;
-procedure lpeUString_ADD_SString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PShortString(Right)^; end;
-procedure lpeUString_ADD_AString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PAnsiString(Right)^; end;
-procedure lpeUString_ADD_WString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PWideString(Right)^; end;
-procedure lpeUString_ADD_UString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PUnicodeString(Right)^; end;
-procedure lpeUString_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PUnicodeString(Left)^ + PVariant(Right)^; end;
-procedure lpeUString_ADD_WChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PWideChar(Right)^; end;
-procedure lpeUString_ADD_AChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PAnsiChar(Right)^; end;
+procedure lpeUString_ASGN_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PShortString(Left)^; end;
+procedure lpeUString_ASGN_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PAnsiString(Left)^; end;
+procedure lpeUString_ASGN_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PWideString(Left)^; end;
+procedure lpeUString_ASGN_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PUnicodeString(Left)^; end;
+procedure lpeUString_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PVariant(Left)^; end;
+procedure lpeUString_ASGN_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PWideChar(Left)^; end;
+procedure lpeUString_ASGN_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PAnsiChar(Left)^; end;
+procedure lpeUString_ADD_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PShortString(Right)^; end;
+procedure lpeUString_ADD_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PAnsiString(Right)^; end;
+procedure lpeUString_ADD_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PWideString(Right)^; end;
+procedure lpeUString_ADD_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PUnicodeString(Right)^; end;
+procedure lpeUString_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PUnicodeString(Left)^ + PVariant(Right)^; end;
+procedure lpeUString_ADD_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PWideChar(Right)^; end;
+procedure lpeUString_ADD_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PUnicodeString(Left)^ + PAnsiChar(Right)^; end;
 
 //AnsiChar
-procedure lpeAChar_EQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PShortString(Right)^; end;
-procedure lpeAChar_EQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PAnsiString(Right)^; end;
-procedure lpeAChar_EQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PWideString(Right)^; end;
-procedure lpeAChar_EQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PUnicodeString(Right)^; end;
-procedure lpeAChar_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PVariant(Right)^; end;
-procedure lpeAChar_GT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PShortString(Right)^; end;
-procedure lpeAChar_GT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PAnsiString(Right)^; end;
-procedure lpeAChar_GT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PWideString(Right)^; end;
-procedure lpeAChar_GT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PUnicodeString(Right)^; end;
-procedure lpeAChar_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PVariant(Right)^; end;
-procedure lpeAChar_GTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PShortString(Right)^; end;
-procedure lpeAChar_GTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PAnsiString(Right)^; end;
-procedure lpeAChar_GTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PWideString(Right)^; end;
-procedure lpeAChar_GTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PUnicodeString(Right)^; end;
-procedure lpeAChar_GTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PVariant(Right)^; end;
-procedure lpeAChar_LT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PShortString(Right)^; end;
-procedure lpeAChar_LT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PAnsiString(Right)^; end;
-procedure lpeAChar_LT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PWideString(Right)^; end;
-procedure lpeAChar_LT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PUnicodeString(Right)^; end;
-procedure lpeAChar_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PVariant(Right)^; end;
-procedure lpeAChar_LTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PShortString(Right)^; end;
-procedure lpeAChar_LTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PAnsiString(Right)^; end;
-procedure lpeAChar_LTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PWideString(Right)^; end;
-procedure lpeAChar_LTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PUnicodeString(Right)^; end;
-procedure lpeAChar_LTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PVariant(Right)^; end;
-procedure lpeAChar_NEQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PShortString(Right)^; end;
-procedure lpeAChar_NEQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PAnsiString(Right)^; end;
-procedure lpeAChar_NEQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PWideString(Right)^; end;
-procedure lpeAChar_NEQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PUnicodeString(Right)^; end;
-procedure lpeAChar_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PVariant(Right)^; end;
+procedure lpeAChar_EQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PShortString(Right)^; end;
+procedure lpeAChar_EQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PAnsiString(Right)^; end;
+procedure lpeAChar_EQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PWideString(Right)^; end;
+procedure lpeAChar_EQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PUnicodeString(Right)^; end;
+procedure lpeAChar_EQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ = PVariant(Right)^; end;
+procedure lpeAChar_GT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PShortString(Right)^; end;
+procedure lpeAChar_GT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PAnsiString(Right)^; end;
+procedure lpeAChar_GT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PWideString(Right)^; end;
+procedure lpeAChar_GT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PUnicodeString(Right)^; end;
+procedure lpeAChar_GT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ > PVariant(Right)^; end;
+procedure lpeAChar_GTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PShortString(Right)^; end;
+procedure lpeAChar_GTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PAnsiString(Right)^; end;
+procedure lpeAChar_GTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PWideString(Right)^; end;
+procedure lpeAChar_GTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PUnicodeString(Right)^; end;
+procedure lpeAChar_GTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ >= PVariant(Right)^; end;
+procedure lpeAChar_LT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PShortString(Right)^; end;
+procedure lpeAChar_LT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PAnsiString(Right)^; end;
+procedure lpeAChar_LT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PWideString(Right)^; end;
+procedure lpeAChar_LT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PUnicodeString(Right)^; end;
+procedure lpeAChar_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ < PVariant(Right)^; end;
+procedure lpeAChar_LTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PShortString(Right)^; end;
+procedure lpeAChar_LTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PAnsiString(Right)^; end;
+procedure lpeAChar_LTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PWideString(Right)^; end;
+procedure lpeAChar_LTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PUnicodeString(Right)^; end;
+procedure lpeAChar_LTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <= PVariant(Right)^; end;
+procedure lpeAChar_NEQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PShortString(Right)^; end;
+procedure lpeAChar_NEQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PAnsiString(Right)^; end;
+procedure lpeAChar_NEQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PWideString(Right)^; end;
+procedure lpeAChar_NEQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PUnicodeString(Right)^; end;
+procedure lpeAChar_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PAnsiChar(Left)^ <> PVariant(Right)^; end;
 
-procedure lpeAChar_ADD_SString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PAnsiChar(Left)^ + PShortString(Right)^; end;
-procedure lpeAChar_ADD_AString(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PAnsiChar(Left)^ + PAnsiString(Right)^; end;
-procedure lpeAChar_ADD_WString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PAnsiChar(Left)^ + PWideString(Right)^; end;
-procedure lpeAChar_ADD_UString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PAnsiChar(Left)^ + PUnicodeString(Right)^; end;
-procedure lpeAChar_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PAnsiChar(Left)^ + PVariant(Right)^; end;
-procedure lpeAChar_ADD_AChar(const Dest, Left, Right: Pointer); begin PAnsiString(Dest)^ := PAnsiChar(Left)^ + PAnsiChar(Right)^; end;
-procedure lpeAChar_ADD_WChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PAnsiChar(Left)^ + PWideChar(Right)^; end;
+procedure lpeAChar_ADD_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PAnsiChar(Left)^ + PShortString(Right)^; end;
+procedure lpeAChar_ADD_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PAnsiChar(Left)^ + PAnsiString(Right)^; end;
+procedure lpeAChar_ADD_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PAnsiChar(Left)^ + PWideString(Right)^; end;
+procedure lpeAChar_ADD_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PAnsiChar(Left)^ + PUnicodeString(Right)^; end;
+procedure lpeAChar_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PAnsiChar(Left)^ + PVariant(Right)^; end;
+procedure lpeAChar_ADD_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiString(Dest)^ := PAnsiChar(Left)^ + PAnsiChar(Right)^; end;
+procedure lpeAChar_ADD_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PAnsiChar(Left)^ + PWideChar(Right)^; end;
 {$IFDEF FPC}
-procedure lpeAChar_ASGN_Variant(const Dest, Left, Right: Pointer); begin PAnsiChar(Dest)^ := PVariant(Left)^; end;
+procedure lpeAChar_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PAnsiChar(Dest)^ := PVariant(Left)^; end;
 {$ENDIF}
 
 //WideChar
-procedure lpeWChar_EQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ = PShortString(Right)^; end;
-procedure lpeWChar_EQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ = PAnsiString(Right)^; end;
-procedure lpeWChar_EQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ = PWideString(Right)^; end;
-procedure lpeWChar_EQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ = PUnicodeString(Right)^; end;
-procedure lpeWChar_EQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ = PVariant(Right)^; end;
-procedure lpeWChar_GT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ > PShortString(Right)^; end;
-procedure lpeWChar_GT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ > PAnsiString(Right)^; end;
-procedure lpeWChar_GT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ > PWideString(Right)^; end;
-procedure lpeWChar_GT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ > PUnicodeString(Right)^; end;
-procedure lpeWChar_GT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ > PVariant(Right)^; end;
-procedure lpeWChar_GTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PShortString(Right)^; end;
-procedure lpeWChar_GTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PAnsiString(Right)^; end;
-procedure lpeWChar_GTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PWideString(Right)^; end;
-procedure lpeWChar_GTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PUnicodeString(Right)^; end;
-procedure lpeWChar_GTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PVariant(Right)^; end;
-procedure lpeWChar_LT_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ < PShortString(Right)^; end;
-procedure lpeWChar_LT_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ < PAnsiString(Right)^; end;
-procedure lpeWChar_LT_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ < PWideString(Right)^; end;
-procedure lpeWChar_LT_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ < PUnicodeString(Right)^; end;
-procedure lpeWChar_LT_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ < PVariant(Right)^; end;
-procedure lpeWChar_LTE_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PShortString(Right)^; end;
-procedure lpeWChar_LTE_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PAnsiString(Right)^; end;
-procedure lpeWChar_LTE_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PWideString(Right)^; end;
-procedure lpeWChar_LTE_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PUnicodeString(Right)^; end;
-procedure lpeWChar_LTE_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PVariant(Right)^; end;
-procedure lpeWChar_NEQ_SString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PShortString(Right)^; end;
-procedure lpeWChar_NEQ_AString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PAnsiString(Right)^; end;
-procedure lpeWChar_NEQ_WString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PWideString(Right)^; end;
-procedure lpeWChar_NEQ_UString(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PUnicodeString(Right)^; end;
-procedure lpeWChar_NEQ_Variant(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PVariant(Right)^; end;
+procedure lpeWChar_EQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ = PShortString(Right)^; end;
+procedure lpeWChar_EQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ = PAnsiString(Right)^; end;
+procedure lpeWChar_EQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ = PWideString(Right)^; end;
+procedure lpeWChar_EQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ = PUnicodeString(Right)^; end;
+procedure lpeWChar_EQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ = PVariant(Right)^; end;
+procedure lpeWChar_GT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ > PShortString(Right)^; end;
+procedure lpeWChar_GT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ > PAnsiString(Right)^; end;
+procedure lpeWChar_GT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ > PWideString(Right)^; end;
+procedure lpeWChar_GT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ > PUnicodeString(Right)^; end;
+procedure lpeWChar_GT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ > PVariant(Right)^; end;
+procedure lpeWChar_GTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PShortString(Right)^; end;
+procedure lpeWChar_GTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PAnsiString(Right)^; end;
+procedure lpeWChar_GTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PWideString(Right)^; end;
+procedure lpeWChar_GTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PUnicodeString(Right)^; end;
+procedure lpeWChar_GTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ >= PVariant(Right)^; end;
+procedure lpeWChar_LT_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ < PShortString(Right)^; end;
+procedure lpeWChar_LT_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ < PAnsiString(Right)^; end;
+procedure lpeWChar_LT_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ < PWideString(Right)^; end;
+procedure lpeWChar_LT_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ < PUnicodeString(Right)^; end;
+procedure lpeWChar_LT_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ < PVariant(Right)^; end;
+procedure lpeWChar_LTE_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PShortString(Right)^; end;
+procedure lpeWChar_LTE_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PAnsiString(Right)^; end;
+procedure lpeWChar_LTE_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PWideString(Right)^; end;
+procedure lpeWChar_LTE_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PUnicodeString(Right)^; end;
+procedure lpeWChar_LTE_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <= PVariant(Right)^; end;
+procedure lpeWChar_NEQ_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PShortString(Right)^; end;
+procedure lpeWChar_NEQ_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PAnsiString(Right)^; end;
+procedure lpeWChar_NEQ_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PWideString(Right)^; end;
+procedure lpeWChar_NEQ_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PUnicodeString(Right)^; end;
+procedure lpeWChar_NEQ_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PWideChar(Left)^ <> PVariant(Right)^; end;
 
-procedure lpeWChar_ADD_SString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PWideChar(Left)^ + PShortString(Right)^; end;
-procedure lpeWChar_ADD_AString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PWideChar(Left)^ + PAnsiString(Right)^; end;
-procedure lpeWChar_ADD_WString(const Dest, Left, Right: Pointer); begin PWideString(Dest)^ := PWideChar(Left)^ + PWideString(Right)^; end;
-procedure lpeWChar_ADD_UString(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PAnsiChar(Left)^ + PUnicodeString(Right)^; end;
-procedure lpeWChar_ADD_Variant(const Dest, Left, Right: Pointer); begin PVariant(Dest)^ := PAnsiChar(Left)^ + PVariant(Right)^; end;
-procedure lpeWChar_ADD_WChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PWideChar(Left)^ + PWideChar(Right)^; end;
-procedure lpeWChar_ADD_AChar(const Dest, Left, Right: Pointer); begin PUnicodeString(Dest)^ := PWideChar(Left)^ + PAnsiChar(Right)^; end;
+procedure lpeWChar_ADD_SString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PWideChar(Left)^ + PShortString(Right)^; end;
+procedure lpeWChar_ADD_AString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PWideChar(Left)^ + PAnsiString(Right)^; end;
+procedure lpeWChar_ADD_WString(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideString(Dest)^ := PWideChar(Left)^ + PWideString(Right)^; end;
+procedure lpeWChar_ADD_UString(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PAnsiChar(Left)^ + PUnicodeString(Right)^; end;
+procedure lpeWChar_ADD_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PVariant(Dest)^ := PAnsiChar(Left)^ + PVariant(Right)^; end;
+procedure lpeWChar_ADD_WChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PWideChar(Left)^ + PWideChar(Right)^; end;
+procedure lpeWChar_ADD_AChar(const Dest, Left, Right: Pointer);  lape_extdecl begin PUnicodeString(Dest)^ := PWideChar(Left)^ + PAnsiChar(Right)^; end;
 {$IFDEF FPC}
-procedure lpeWChar_ASGN_Variant(const Dest, Left, Right: Pointer); begin PWideChar(Dest)^ := PVariant(Left)^; end;
+procedure lpeWChar_ASGN_Variant(const Dest, Left, Right: Pointer);  lape_extdecl begin PWideChar(Dest)^ := PVariant(Left)^; end;
 {$ENDIF}
 
 //Pointer
-procedure lpePointer_EQ_Pointer(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PPointer(Left)^ = PPointer(Right)^; end;
-procedure lpePointer_GT_Pointer(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PtrUInt(PPointer(Left)^) > PtrUInt(PPointer(Right)^); end;
-procedure lpePointer_GTEQ_Pointer(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PtrUInt(PPointer(Left)^) >= PtrUInt(PPointer(Right)^); end;
-procedure lpePointer_LT_Pointer(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PtrUInt(PPointer(Left)^) < PtrUInt(PPointer(Right)^); end;
-procedure lpePointer_LTEQ_Pointer(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PtrUInt(PPointer(Left)^) <= PtrUInt(PPointer(Right)^); end;
-procedure lpePointer_NEQ_Pointer(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PPointer(Left)^ <> PPointer(Right)^; end;
-procedure lpePointer_ASGN_Pointer(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := PPointer(Left)^; end;
-procedure lpePointer_ASGN_SMethod(const Dest, Left, Right: Pointer); begin PCodePos(Dest)^ := PtrUInt(PPointer(Left)^); end;
+procedure lpePointer_EQ_Pointer(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PPointer(Left)^ = PPointer(Right)^; end;
+procedure lpePointer_GT_Pointer(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PtrUInt(PPointer(Left)^) > PtrUInt(PPointer(Right)^); end;
+procedure lpePointer_GTEQ_Pointer(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PtrUInt(PPointer(Left)^) >= PtrUInt(PPointer(Right)^); end;
+procedure lpePointer_LT_Pointer(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PtrUInt(PPointer(Left)^) < PtrUInt(PPointer(Right)^); end;
+procedure lpePointer_LTEQ_Pointer(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PtrUInt(PPointer(Left)^) <= PtrUInt(PPointer(Right)^); end;
+procedure lpePointer_NEQ_Pointer(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PPointer(Left)^ <> PPointer(Right)^; end;
+procedure lpePointer_ASGN_Pointer(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := PPointer(Left)^; end;
+procedure lpePointer_ASGN_SMethod(const Dest, Left, Right: Pointer);  lape_extdecl begin PCodePos(Dest)^ := PtrUInt(PPointer(Left)^); end;
 
-procedure lpePointer_ADD_UInt8(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt8(Right)^); end;
-procedure lpePointer_ADD_Int8(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt8(Right)^); end;
-procedure lpePointer_ADD_UInt16(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt16(Right)^); end;
-procedure lpePointer_ADD_Int16(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt16(Right)^); end;
-procedure lpePointer_ADD_UInt32(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt32(Right)^); end;
-procedure lpePointer_ADD_Int32(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt32(Right)^); end;
-procedure lpePointer_ADD_UInt64(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt64(Right)^); end;
-procedure lpePointer_ADD_Int64(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt64(Right)^); end;
+procedure lpePointer_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt8(Right)^); end;
+procedure lpePointer_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt8(Right)^); end;
+procedure lpePointer_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt16(Right)^); end;
+procedure lpePointer_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt16(Right)^); end;
+procedure lpePointer_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt32(Right)^); end;
+procedure lpePointer_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt32(Right)^); end;
+procedure lpePointer_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt64(Right)^); end;
+procedure lpePointer_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt64(Right)^); end;
 
-procedure lpePointer_SUB_UInt8(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt8(Right)^); end;
-procedure lpePointer_SUB_Int8(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt8(Right)^); end;
-procedure lpePointer_SUB_UInt16(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt16(Right)^); end;
-procedure lpePointer_SUB_Int16(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt16(Right)^); end;
-procedure lpePointer_SUB_UInt32(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt32(Right)^); end;
-procedure lpePointer_SUB_Int32(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt32(Right)^); end;
-procedure lpePointer_SUB_UInt64(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt64(Right)^); end;
-procedure lpePointer_SUB_Int64(const Dest, Left, Right: Pointer); begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt64(Right)^); end;
+procedure lpePointer_SUB_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt8(Right)^); end;
+procedure lpePointer_SUB_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt8(Right)^); end;
+procedure lpePointer_SUB_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt16(Right)^); end;
+procedure lpePointer_SUB_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt16(Right)^); end;
+procedure lpePointer_SUB_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt32(Right)^); end;
+procedure lpePointer_SUB_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt32(Right)^); end;
+procedure lpePointer_SUB_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrUInt(PPointer(Left)^) + PUInt64(Right)^); end;
+procedure lpePointer_SUB_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PPointer(Dest)^ := Pointer(PtrInt(PPointer(Left)^) + PInt64(Right)^); end;
 
 //Method
-procedure lpeDot(const Dest, Left, Right: Pointer); begin TMethod(Dest^).Data := Left; TMethod(Dest^).Code := PPointer(Right)^; end;
-procedure lpeSMethod_ASGN_Pointer(const Dest, Left, Right: Pointer); begin PCodePos(Dest)^ := PtrUInt(PPointer(Left)^); end;
-procedure lpeSMethod_ASGN_SMethod(const Dest, Left, Right: Pointer); begin PCodePos(Dest)^ := PCodePos(Left)^; end;
+procedure lpeDot(const Dest, Left, Right: Pointer);  lape_extdecl begin TMethod(Dest^).Data := Left; TMethod(Dest^).Code := PPointer(Right)^; end;
+procedure lpeSMethod_ASGN_Pointer(const Dest, Left, Right: Pointer);  lape_extdecl begin PCodePos(Dest)^ := PtrUInt(PPointer(Left)^); end;
+procedure lpeSMethod_ASGN_SMethod(const Dest, Left, Right: Pointer);  lape_extdecl begin PCodePos(Dest)^ := PCodePos(Left)^; end;
 
 //Set
 //small set
-procedure lpeSSet_EQ_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeSmallSet(Left)^ = PLapeSmallSet(Right)^; end;
-procedure lpeSSet_GTE_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeSmallSet(Left)^ >= PLapeSmallSet(Right)^; end;
-procedure lpeSSet_LTE_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeSmallSet(Left)^ <= PLapeSmallSet(Right)^; end;
-procedure lpeSSet_NE_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeSmallSet(Left)^ <> PLapeSmallSet(Right)^; end;
+procedure lpeSSet_EQ_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeSmallSet(Left)^ = PLapeSmallSet(Right)^; end;
+procedure lpeSSet_GTE_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeSmallSet(Left)^ >= PLapeSmallSet(Right)^; end;
+procedure lpeSSet_LTE_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeSmallSet(Left)^ <= PLapeSmallSet(Right)^; end;
+procedure lpeSSet_NE_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeSmallSet(Left)^ <> PLapeSmallSet(Right)^; end;
 
-procedure lpeInt8_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeSmallEnum(PInt8(Left)^) in PLapeSmallSet(Right)^; end;
-procedure lpeUInt8_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeSmallEnum(PUInt8(Left)^) in PLapeSmallSet(Right)^; end;
-procedure lpeInt16_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeSmallEnum(PInt16(Left)^) in PLapeSmallSet(Right)^; end;
-procedure lpeUInt16_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeSmallEnum(PUInt16(Left)^) in PLapeSmallSet(Right)^; end;
-procedure lpeInt32_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeSmallEnum(PInt32(Left)^) in PLapeSmallSet(Right)^; end;
-procedure lpeUInt32_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeSmallEnum(PUInt32(Left)^) in PLapeSmallSet(Right)^; end;
-procedure lpeInt64_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeSmallEnum(PInt64(Left)^) in PLapeSmallSet(Right)^; end;
-procedure lpeUInt64_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeSmallEnum(PUInt64(Left)^) in PLapeSmallSet(Right)^; end;
-procedure lpeSEnum_IN_SSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeSmallEnum(Left)^ in PLapeSmallSet(Right)^; end;
+procedure lpeInt8_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeSmallEnum(PInt8(Left)^) in PLapeSmallSet(Right)^; end;
+procedure lpeUInt8_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeSmallEnum(PUInt8(Left)^) in PLapeSmallSet(Right)^; end;
+procedure lpeInt16_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeSmallEnum(PInt16(Left)^) in PLapeSmallSet(Right)^; end;
+procedure lpeUInt16_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeSmallEnum(PUInt16(Left)^) in PLapeSmallSet(Right)^; end;
+procedure lpeInt32_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeSmallEnum(PInt32(Left)^) in PLapeSmallSet(Right)^; end;
+procedure lpeUInt32_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeSmallEnum(PUInt32(Left)^) in PLapeSmallSet(Right)^; end;
+procedure lpeInt64_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeSmallEnum(PInt64(Left)^) in PLapeSmallSet(Right)^; end;
+procedure lpeUInt64_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeSmallEnum(PUInt64(Left)^) in PLapeSmallSet(Right)^; end;
+procedure lpeSEnum_IN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeSmallEnum(Left)^ in PLapeSmallSet(Right)^; end;
 
-procedure lpeSSet_ADD_Int8(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PInt8(Right)^)]; end;
-procedure lpeSSet_ADD_UInt8(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PUInt8(Right)^)]; end;
-procedure lpeSSet_ADD_Int16(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PInt16(Right)^)]; end;
-procedure lpeSSet_ADD_UInt16(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PUInt16(Right)^)]; end;
-procedure lpeSSet_ADD_Int32(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PInt32(Right)^)]; end;
-procedure lpeSSet_ADD_UInt32(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PUInt32(Right)^)]; end;
-procedure lpeSSet_ADD_Int64(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PInt64(Right)^)]; end;
-procedure lpeSSet_ADD_UInt64(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PUInt64(Right)^)]; end;
-procedure lpeSSet_ADD_SEnum(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [PLapeSmallEnum(Right)^]; end;
+procedure lpeSSet_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PInt8(Right)^)]; end;
+procedure lpeSSet_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PUInt8(Right)^)]; end;
+procedure lpeSSet_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PInt16(Right)^)]; end;
+procedure lpeSSet_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PUInt16(Right)^)]; end;
+procedure lpeSSet_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PInt32(Right)^)]; end;
+procedure lpeSSet_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PUInt32(Right)^)]; end;
+procedure lpeSSet_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PInt64(Right)^)]; end;
+procedure lpeSSet_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [ELapeSmallEnum(PUInt64(Right)^)]; end;
+procedure lpeSSet_ADD_SEnum(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + [PLapeSmallEnum(Right)^]; end;
 
-procedure lpeSSet_ASGN_SSet(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^; end;
-procedure lpeSSet_ADD_SSet(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + PLapeSmallSet(Right)^; end;
-procedure lpeSSet_SUB_SSet(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ - PLapeSmallSet(Right)^; end;
-procedure lpeSSet_MUL_SSet(const Dest, Left, Right: Pointer); begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ * PLapeSmallSet(Right)^; end;
+procedure lpeSSet_ASGN_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^; end;
+procedure lpeSSet_ADD_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ + PLapeSmallSet(Right)^; end;
+procedure lpeSSet_SUB_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ - PLapeSmallSet(Right)^; end;
+procedure lpeSSet_MUL_SSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeSmallSet(Dest)^ := PLapeSmallSet(Left)^ * PLapeSmallSet(Right)^; end;
 
 //large set
-procedure lpeLSet_EQ_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeLargeSet(Left)^ = PLapeLargeSet(Right)^; end;
-procedure lpeLSet_GTE_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeLargeSet(Left)^ >= PLapeLargeSet(Right)^; end;
-procedure lpeLSet_LTE_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeLargeSet(Left)^ <= PLapeLargeSet(Right)^; end;
-procedure lpeLSet_NE_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeLargeSet(Left)^ <> PLapeLargeSet(Right)^; end;
+procedure lpeLSet_EQ_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeLargeSet(Left)^ = PLapeLargeSet(Right)^; end;
+procedure lpeLSet_GTE_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeLargeSet(Left)^ >= PLapeLargeSet(Right)^; end;
+procedure lpeLSet_LTE_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeLargeSet(Left)^ <= PLapeLargeSet(Right)^; end;
+procedure lpeLSet_NE_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeLargeSet(Left)^ <> PLapeLargeSet(Right)^; end;
 
-procedure lpeInt8_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeLargeEnum(PInt8(Left)^) in PLapeLargeSet(Right)^; end;
-procedure lpeUInt8_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeLargeEnum(PUInt8(Left)^) in PLapeLargeSet(Right)^; end;
-procedure lpeInt16_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeLargeEnum(PInt16(Left)^) in PLapeLargeSet(Right)^; end;
-procedure lpeUInt16_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeLargeEnum(PUInt16(Left)^) in PLapeLargeSet(Right)^; end;
-procedure lpeInt32_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeLargeEnum(PInt32(Left)^) in PLapeLargeSet(Right)^; end;
-procedure lpeUInt32_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeLargeEnum(PUInt32(Left)^) in PLapeLargeSet(Right)^; end;
-procedure lpeInt64_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeLargeEnum(PInt64(Left)^) in PLapeLargeSet(Right)^; end;
-procedure lpeUInt64_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := ELapeLargeEnum(PUInt64(Left)^) in PLapeLargeSet(Right)^; end;
-procedure lpeLEnum_IN_LSet(const Dest, Left, Right: Pointer); begin PEvalBool(Dest)^ := PLapeLargeEnum(Left)^ in PLapeLargeSet(Right)^; end;
+procedure lpeInt8_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeLargeEnum(PInt8(Left)^) in PLapeLargeSet(Right)^; end;
+procedure lpeUInt8_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeLargeEnum(PUInt8(Left)^) in PLapeLargeSet(Right)^; end;
+procedure lpeInt16_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeLargeEnum(PInt16(Left)^) in PLapeLargeSet(Right)^; end;
+procedure lpeUInt16_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeLargeEnum(PUInt16(Left)^) in PLapeLargeSet(Right)^; end;
+procedure lpeInt32_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeLargeEnum(PInt32(Left)^) in PLapeLargeSet(Right)^; end;
+procedure lpeUInt32_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeLargeEnum(PUInt32(Left)^) in PLapeLargeSet(Right)^; end;
+procedure lpeInt64_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeLargeEnum(PInt64(Left)^) in PLapeLargeSet(Right)^; end;
+procedure lpeUInt64_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := ELapeLargeEnum(PUInt64(Left)^) in PLapeLargeSet(Right)^; end;
+procedure lpeLEnum_IN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PEvalBool(Dest)^ := PLapeLargeEnum(Left)^ in PLapeLargeSet(Right)^; end;
 
-procedure lpeLSet_ADD_Int8(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PInt8(Right)^)]; end;
-procedure lpeLSet_ADD_UInt8(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PUInt8(Right)^)]; end;
-procedure lpeLSet_ADD_Int16(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PInt16(Right)^)]; end;
-procedure lpeLSet_ADD_UInt16(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PUInt16(Right)^)]; end;
-procedure lpeLSet_ADD_Int32(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PInt32(Right)^)]; end;
-procedure lpeLSet_ADD_UInt32(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PUInt32(Right)^)]; end;
-procedure lpeLSet_ADD_Int64(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PInt64(Right)^)]; end;
-procedure lpeLSet_ADD_UInt64(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PUInt64(Right)^)]; end;
-procedure lpeLSet_ADD_LEnum(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [PLapeLargeEnum(Right)^]; end;
+procedure lpeLSet_ADD_Int8(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PInt8(Right)^)]; end;
+procedure lpeLSet_ADD_UInt8(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PUInt8(Right)^)]; end;
+procedure lpeLSet_ADD_Int16(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PInt16(Right)^)]; end;
+procedure lpeLSet_ADD_UInt16(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PUInt16(Right)^)]; end;
+procedure lpeLSet_ADD_Int32(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PInt32(Right)^)]; end;
+procedure lpeLSet_ADD_UInt32(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PUInt32(Right)^)]; end;
+procedure lpeLSet_ADD_Int64(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PInt64(Right)^)]; end;
+procedure lpeLSet_ADD_UInt64(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [ELapeLargeEnum(PUInt64(Right)^)]; end;
+procedure lpeLSet_ADD_LEnum(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + [PLapeLargeEnum(Right)^]; end;
 
-procedure lpeLSet_ASGN_LSet(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^; end;
-procedure lpeLSet_ADD_LSet(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + PLapeLargeSet(Right)^; end;
-procedure lpeLSet_SUB_LSet(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ - PLapeLargeSet(Right)^; end;
-procedure lpeLSet_MUL_LSet(const Dest, Left, Right: Pointer); begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ * PLapeLargeSet(Right)^; end;
+procedure lpeLSet_ASGN_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^; end;
+procedure lpeLSet_ADD_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ + PLapeLargeSet(Right)^; end;
+procedure lpeLSet_SUB_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ - PLapeLargeSet(Right)^; end;
+procedure lpeLSet_MUL_LSet(const Dest, Left, Right: Pointer);  lape_extdecl begin PLapeLargeSet(Dest)^ := PLapeLargeSet(Left)^ * PLapeLargeSet(Right)^; end;
diff --git a/lpeval_headers_datetime.inc b/lpeval_headers_datetime.inc
index 92c437c..f7704cf 100644
--- a/lpeval_headers_datetime.inc
+++ b/lpeval_headers_datetime.inc
@@ -7,26 +7,26 @@
 }
 {%MainUnit lpeval.pas}
 
-procedure _LapeEncodeDate(const Params: PParamArray; const Result: Pointer);
-procedure _LapeEncodeTime(const Params: PParamArray; const Result: Pointer);
-procedure _LapeDecodeDate(const Params: PParamArray);
-procedure _LapeDecodeDateFully(const Params: PParamArray; const Result: Pointer);
-procedure _LapeDecodeTime(const Params: PParamArray);
+procedure _LapeEncodeDate(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeEncodeTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeDecodeDate(const Params: PParamArray); lape_extdecl
+procedure _LapeDecodeDateFully(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeDecodeTime(const Params: PParamArray); lape_extdecl
 
-procedure _LapeDate(const Params: PParamArray; const Result: Pointer);
-procedure _LapeTime(const Params: PParamArray; const Result: Pointer);
-procedure _LapeNow(const Params: PParamArray; const Result: Pointer);
+procedure _LapeDate(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeNow(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeGetTickCount(const Params: PParamArray; const Result: Pointer);
-procedure _LapeSleep(const Params: PParamArray);
+procedure _LapeGetTickCount(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeSleep(const Params: PParamArray); lape_extdecl
 
-procedure _LapeReplaceTime(const Params: PParamArray);
-procedure _LapeReplaceDate(const Params: PParamArray);
+procedure _LapeReplaceTime(const Params: PParamArray); lape_extdecl
+procedure _LapeReplaceDate(const Params: PParamArray); lape_extdecl
 
-procedure _LapeFormatDateTime(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToDate(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToDateDef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToTime(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToTimeDef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToDateTime(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToDateTimeDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeFormatDateTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToDate(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToDateDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToTimeDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToDateTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToDateTimeDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
diff --git a/lpeval_headers_math.inc b/lpeval_headers_math.inc
index de7db8a..7ff0f32 100644
--- a/lpeval_headers_math.inc
+++ b/lpeval_headers_math.inc
@@ -7,24 +7,24 @@
 }
 {%MainUnit lpeval.pas}
 
-procedure _LapeAbs(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAbsI(const Params: PParamArray; const Result: Pointer);
-procedure _LapeSqr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeSqrt(const Params: PParamArray; const Result: Pointer);
-procedure _LapeArcTan(const Params: PParamArray; const Result: Pointer);
-procedure _LapeLn(const Params: PParamArray; const Result: Pointer);
-procedure _LapeSin(const Params: PParamArray; const Result: Pointer);
-procedure _LapeCos(const Params: PParamArray; const Result: Pointer);
-procedure _LapeExp(const Params: PParamArray; const Result: Pointer);
-procedure _LapeRound(const Params: PParamArray; const Result: Pointer);
-procedure _LapeRoundTo(const Params: PParamArray; const Result: Pointer);
-procedure _LapeFrac(const Params: PParamArray; const Result: Pointer);
-procedure _LapeInt(const Params: PParamArray; const Result: Pointer);
-procedure _LapeTrunc(const Params: PParamArray; const Result: Pointer);
-procedure _LapeCeil(const Params: PParamArray; const Result: Pointer);
-procedure _LapeFloor(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAbs(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAbsI(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeSqr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeSqrt(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeArcTan(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeLn(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeSin(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeCos(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeExp(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeRound(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeRoundTo(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeFrac(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeInt(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeTrunc(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeCeil(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeFloor(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeRandomRange(const Params: PParamArray; const Result: Pointer);
-procedure _LapeRandom(const Params: PParamArray; const Result: Pointer);
-procedure _LapeRandomF(const Params: PParamArray; const Result: Pointer);
-procedure _LapeRandomize(const Params: PParamArray);
+procedure _LapeRandomRange(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeRandom(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeRandomF(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeRandomize(const Params: PParamArray); lape_extdecl
diff --git a/lpeval_headers_string.inc b/lpeval_headers_string.inc
index 9671548..2520076 100644
--- a/lpeval_headers_string.inc
+++ b/lpeval_headers_string.inc
@@ -7,61 +7,61 @@
 }
 {%MainUnit lpeval.pas}
 
-procedure _LapeUpperCase(const Params: PParamArray; const Result: Pointer);
-procedure _LapeLowerCase(const Params: PParamArray; const Result: Pointer);
-procedure _LapeUpCaseA(const Params: PParamArray; const Result: Pointer);
-procedure _LapeUpCaseW(const Params: PParamArray; const Result: Pointer);
+procedure _LapeUpperCase(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeLowerCase(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeUpCaseA(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeUpCaseW(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeCompareStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeCompareMem(const Params: PParamArray; const Result: Pointer);
-procedure _LapeCompareText(const Params: PParamArray; const Result: Pointer);
-procedure _LapeSameText(const Params: PParamArray; const Result: Pointer);
+procedure _LapeCompareStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeCompareMem(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeCompareText(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeSameText(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeAnsiUpperCase(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAnsiLowerCase(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAnsiCompareStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAnsiCompareText(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAnsiSameText(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAnsiSameStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiUpperCase(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAnsiLowerCase(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAnsiCompareStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAnsiCompareText(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAnsiSameText(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAnsiSameStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeTrim(const Params: PParamArray; const Result: Pointer);
-procedure _LapeTrimLeft(const Params: PParamArray; const Result: Pointer);
-procedure _LapeTrimRight(const Params: PParamArray; const Result: Pointer);
-procedure _LapePadL(const Params: PParamArray; const Result: Pointer);
-procedure _LapePadR(const Params: PParamArray; const Result: Pointer);
-procedure _LapeQuotedStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAnsiQuotedStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAnsiDequotedStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeTrim(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeTrimLeft(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeTrimRight(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapePadL(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapePadR(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeQuotedStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAnsiQuotedStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAnsiDequotedStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeWrapText(const Params: PParamArray; const Result: Pointer);
-procedure _LapeAdjustLineBreaks(const Params: PParamArray; const Result: Pointer);
+procedure _LapeWrapText(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeAdjustLineBreaks(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeIntToHex(const Params: PParamArray; const Result: Pointer);
-procedure _LapeUIntToHex(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToInt(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToIntDef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToInt64(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToInt64Def(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToUInt64(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToUInt64Def(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToFloat(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToFloatDef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToCurr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToCurrDef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToBool(const Params: PParamArray; const Result: Pointer);
-procedure _LapeBoolToStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStrToBoolDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeIntToHex(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeUIntToHex(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToInt(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToIntDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToInt64(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToInt64Def(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToUInt64(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToUInt64Def(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToFloat(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToFloatDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToCurr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToCurrDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToBool(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeBoolToStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStrToBoolDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeFormat(const Params: PParamArray; const Result: Pointer);
-procedure _LapeFormatFloat(const Params: PParamArray; const Result: Pointer);
-procedure _LapeFormatCurr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeFormat(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeFormatFloat(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeFormatCurr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapeLastDelimiter(const Params: PParamArray; const Result: Pointer);
-procedure _LapeStringReplace(const Params: PParamArray; const Result: Pointer);
-procedure _LapeIsDelimiter(const Params: PParamArray; const Result: Pointer);
+procedure _LapeLastDelimiter(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeStringReplace(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeIsDelimiter(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
-procedure _LapePos(const Params: PParamArray; const Result: Pointer);
-procedure _LapeCopy(const Params: PParamArray; const Result: Pointer);
-procedure _LapeInsert(const Params: PParamArray);
-procedure _LapeDelete(const Params: PParamArray);
-procedure _LapeStringOfChar(const Params: PParamArray; const Result: Pointer);
+procedure _LapePos(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeCopy(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeInsert(const Params: PParamArray); lape_extdecl
+procedure _LapeDelete(const Params: PParamArray); lape_extdecl
+procedure _LapeStringOfChar(const Params: PParamArray; const Result: Pointer); lape_extdecl
diff --git a/lpeval_headers_variant.inc b/lpeval_headers_variant.inc
index 6e5801c..edb4190 100644
--- a/lpeval_headers_variant.inc
+++ b/lpeval_headers_variant.inc
@@ -7,55 +7,55 @@
 }
 {%MainUnit lpeval.pas}
 
-procedure _LapeVarType(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarAsType(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarIsByRef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarIsEmpty(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarIsNull(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarIsClear(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarIsError(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarAsError(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarIsCustom(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarIsOrdinal(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarIsFloat(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarIsNumeric(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarIsStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarIsArray(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarToStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarToStrDef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarToWideStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarToWideStrDef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarToUnicodeStr(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarToUnicodeStrDef(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarToDateTime(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarFromDateTime(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarInRange(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarEnsureRange(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarSameValue(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarCompareValue(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarTypeIsValidArrayType(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarTypeIsValidElementType(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarArrayCreate(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarArrayOf(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarArrayRedim(const Params: PParamArray);
-
-procedure _LapeVarArrayAsPSafeArray(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarCopyNoInd(const Params: PParamArray);
-
-procedure _LapeVarArrayDimCount(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarArrayLowBound(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarArrayHighBound(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarArrayLock(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarArrayUnlock(const Params: PParamArray);
-procedure _LapeVarArrayRef(const Params: PParamArray; const Result: Pointer);
-
-procedure _LapeVarArrayGet(const Params: PParamArray; const Result: Pointer);
-procedure _LapeVarArraySet(const Params: PParamArray);
+procedure _LapeVarType(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarAsType(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarIsByRef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarIsEmpty(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarIsNull(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarIsClear(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarIsError(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarAsError(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarIsCustom(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarIsOrdinal(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarIsFloat(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarIsNumeric(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarIsStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarIsArray(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarToStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarToStrDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarToWideStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarToWideStrDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarToUnicodeStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarToUnicodeStrDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarToDateTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarFromDateTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarInRange(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarEnsureRange(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarSameValue(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarCompareValue(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarTypeIsValidArrayType(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarTypeIsValidElementType(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarArrayCreate(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarArrayOf(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarArrayRedim(const Params: PParamArray); lape_extdecl
+
+procedure _LapeVarArrayAsPSafeArray(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarCopyNoInd(const Params: PParamArray); lape_extdecl
+
+procedure _LapeVarArrayDimCount(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarArrayLowBound(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarArrayHighBound(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarArrayLock(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarArrayUnlock(const Params: PParamArray); lape_extdecl
+procedure _LapeVarArrayRef(const Params: PParamArray; const Result: Pointer); lape_extdecl
+
+procedure _LapeVarArrayGet(const Params: PParamArray; const Result: Pointer); lape_extdecl
+procedure _LapeVarArraySet(const Params: PParamArray); lape_extdecl
diff --git a/lpeval_wrappers_datetime.inc b/lpeval_wrappers_datetime.inc
index bb6b476..53e3cfc 100644
--- a/lpeval_wrappers_datetime.inc
+++ b/lpeval_wrappers_datetime.inc
@@ -7,47 +7,47 @@
 }
 {%MainUnit lpeval.pas}
 
-procedure _LapeEncodeDate(const Params: PParamArray; const Result: Pointer);
+procedure _LapeEncodeDate(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := EncodeDate(PUInt16(Params^[0])^, PUInt16(Params^[1])^, PUInt16(Params^[2])^);
 end;
 
-procedure _LapeEncodeTime(const Params: PParamArray; const Result: Pointer);
+procedure _LapeEncodeTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := EncodeTime(PUInt16(Params^[0])^, PUInt16(Params^[1])^, PUInt16(Params^[2])^, PUInt16(Params^[3])^);
 end;
 
-procedure _LapeDecodeDate(const Params: PParamArray);
+procedure _LapeDecodeDate(const Params: PParamArray); lape_extdecl
 begin
   DecodeDate(PDateTime(Params^[0])^, PUInt16(Params^[1])^, PUInt16(Params^[2])^, PUInt16(Params^[3])^);
 end;
 
-procedure _LapeDecodeDateFully(const Params: PParamArray; const Result: Pointer);
+procedure _LapeDecodeDateFully(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PBoolean(Result)^ := DecodeDateFully(PDateTime(Params^[0])^, PUInt16(Params^[1])^, PUInt16(Params^[2])^, PUInt16(Params^[3])^, PUInt16(Params^[4])^);
 end;
 
-procedure _LapeDecodeTime(const Params: PParamArray);
+procedure _LapeDecodeTime(const Params: PParamArray); lape_extdecl
 begin
   DecodeTime(PDateTime(Params^[0])^, PUInt16(Params^[1])^, PUInt16(Params^[2])^, PUInt16(Params^[3])^, PUInt16(Params^[4])^);
 end;
 
-procedure _LapeDate(const Params: PParamArray; const Result: Pointer);
+procedure _LapeDate(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := Date();
 end;
 
-procedure _LapeTime(const Params: PParamArray; const Result: Pointer);
+procedure _LapeTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := Time();
 end;
 
-procedure _LapeNow(const Params: PParamArray; const Result: Pointer);
+procedure _LapeNow(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := Now();
 end;
 
-procedure _LapeGetTickCount(const Params: PParamArray; const Result: Pointer);
+procedure _LapeGetTickCount(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   {$IF DECLARED(GetTickCount)}
   PUInt32(Result)^ := GetTickCount();
@@ -56,52 +56,52 @@ begin
   {$IFEND}
 end;
 
-procedure _LapeSleep(const Params: PParamArray);
+procedure _LapeSleep(const Params: PParamArray); lape_extdecl
 begin
   Sleep(PUInt32(Params^[0])^);
 end;
 
-procedure _LapeReplaceTime(const Params: PParamArray);
+procedure _LapeReplaceTime(const Params: PParamArray); lape_extdecl
 begin
   ReplaceTime(PDateTime(Params^[0])^, PDateTime(Params^[1])^);
 end;
 
-procedure _LapeReplaceDate(const Params: PParamArray);
+procedure _LapeReplaceDate(const Params: PParamArray); lape_extdecl
 begin
   ReplaceDate(PDateTime(Params^[0])^, PDateTime(Params^[1])^);
 end;
 
-procedure _LapeFormatDateTime(const Params: PParamArray; const Result: Pointer);
+procedure _LapeFormatDateTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := FormatDateTime(PlpString(Params^[0])^, PDateTime(Params^[1])^);
 end;
 
-procedure _LapeStrToDate(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToDate(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := StrToDate(PlpString(Params^[0])^);
 end;
 
-procedure _LapeStrToDateDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToDateDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := StrToDateDef(PlpString(Params^[0])^, PDateTime(Params^[1])^);
 end;
 
-procedure _LapeStrToTime(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := StrToTime(PlpString(Params^[0])^);
 end;
 
-procedure _LapeStrToTimeDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToTimeDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := StrToTimeDef(PlpString(Params^[0])^, PDateTime(Params^[1])^);
 end;
 
-procedure _LapeStrToDateTime(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToDateTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := StrToDateTime(PlpString(Params^[0])^);
 end;
 
-procedure _LapeStrToDateTimeDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToDateTimeDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := StrToDateTimeDef(PlpString(Params^[0])^, PDateTime(Params^[1])^);
 end;
diff --git a/lpeval_wrappers_math.inc b/lpeval_wrappers_math.inc
index ad5942f..4e0229d 100644
--- a/lpeval_wrappers_math.inc
+++ b/lpeval_wrappers_math.inc
@@ -7,102 +7,102 @@
 }
 {%MainUnit lpeval.pas}
 
-procedure _LapeAbs(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAbs(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Abs(PExtended(Params^[0])^);
 end;
 
-procedure _LapeAbsI(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAbsI(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt64(Result)^ := Abs(PInt64(Params^[0])^);
 end;
 
-procedure _LapeSqr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeSqr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Sqr(PExtended(Params^[0])^);
 end;
 
-procedure _LapeSqrt(const Params: PParamArray; const Result: Pointer);
+procedure _LapeSqrt(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Sqrt(PExtended(Params^[0])^);
 end;
 
-procedure _LapeArcTan(const Params: PParamArray; const Result: Pointer);
+procedure _LapeArcTan(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := ArcTan(PExtended(Params^[0])^);
 end;
 
-procedure _LapeLn(const Params: PParamArray; const Result: Pointer);
+procedure _LapeLn(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Ln(PExtended(Params^[0])^);
 end;
 
-procedure _LapeSin(const Params: PParamArray; const Result: Pointer);
+procedure _LapeSin(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Sin(PExtended(Params^[0])^);
 end;
 
-procedure _LapeCos(const Params: PParamArray; const Result: Pointer);
+procedure _LapeCos(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Cos(PExtended(Params^[0])^);
 end;
 
-procedure _LapeExp(const Params: PParamArray; const Result: Pointer);
+procedure _LapeExp(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Exp(PExtended(Params^[0])^);
 end;
 
-procedure _LapeRound(const Params: PParamArray; const Result: Pointer);
+procedure _LapeRound(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt64(Result)^ := Round(PExtended(Params^[0])^);
 end;
 
-procedure _LapeRoundTo(const Params: PParamArray; const Result: Pointer);
+procedure _LapeRoundTo(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := RoundTo(PExtended(Params^[0])^, -PInt8(Params^[1])^);
 end;
 
-procedure _LapeFrac(const Params: PParamArray; const Result: Pointer);
+procedure _LapeFrac(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Frac(PExtended(Params^[0])^);
 end;
 
-procedure _LapeInt(const Params: PParamArray; const Result: Pointer);
+procedure _LapeInt(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Int(PExtended(Params^[0])^);
 end;
 
-procedure _LapeTrunc(const Params: PParamArray; const Result: Pointer);
+procedure _LapeTrunc(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt64(Result)^ := Trunc(PExtended(Params^[0])^);
 end;
 
-procedure _LapeCeil(const Params: PParamArray; const Result: Pointer);
+procedure _LapeCeil(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt64(Result)^ := Ceil(PExtended(Params^[0])^);
 end;
 
-procedure _LapeFloor(const Params: PParamArray; const Result: Pointer);
+procedure _LapeFloor(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt64(Result)^ := Floor(PExtended(Params^[0])^);
 end;
 
-procedure _LapeRandomRange(const Params: PParamArray; const Result: Pointer);
+procedure _LapeRandomRange(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   Pint64(Result)^ := PInt64(Params^[0])^ + Random(PInt64(Params^[1])^ - PInt64(Params^[0])^ + 1);
 end;
 
-procedure _LapeRandom(const Params: PParamArray; const Result: Pointer);
+procedure _LapeRandom(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   Pint64(Result)^ := Random(PInt64(Params^[0])^);
 end;
 
-procedure _LapeRandomF(const Params: PParamArray; const Result: Pointer);
+procedure _LapeRandomF(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := Random();
 end;
 
-procedure _LapeRandomize(const Params: PParamArray);
+procedure _LapeRandomize(const Params: PParamArray); lape_extdecl
 begin
   Randomize();
 end;
diff --git a/lpeval_wrappers_string.inc b/lpeval_wrappers_string.inc
index 3214b4a..7836e07 100644
--- a/lpeval_wrappers_string.inc
+++ b/lpeval_wrappers_string.inc
@@ -7,112 +7,112 @@
 }
 {%MainUnit lpeval.pas}
 
-procedure _LapeUpperCase(const Params: PParamArray; const Result: Pointer);
+procedure _LapeUpperCase(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := UpperCase(PlpString(Params^[0])^);
 end;
 
-procedure _LapeLowerCase(const Params: PParamArray; const Result: Pointer);
+procedure _LapeLowerCase(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := LowerCase(PlpString(Params^[0])^);
 end;
 
-procedure _LapeUpCaseA(const Params: PParamArray; const Result: Pointer);
+procedure _LapeUpCaseA(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PAnsiChar(Result)^ := UpCase(PAnsiChar(Params^[0])^);
 end;
 
-procedure _LapeUpCaseW(const Params: PParamArray; const Result: Pointer);
+procedure _LapeUpCaseW(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PWideChar(Result)^ := UpCase(PWideChar(Params^[0])^);
 end;
 
-procedure _LapeCompareStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeCompareStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := CompareStr(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeCompareMem(const Params: PParamArray; const Result: Pointer);
+procedure _LapeCompareMem(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := CompareMem(PPointer(Params^[0])^, PPointer(Params^[1])^, PPtrUInt(Params^[2])^);
 end;
 
-procedure _LapeCompareText(const Params: PParamArray; const Result: Pointer);
+procedure _LapeCompareText(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := CompareText(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeSameText(const Params: PParamArray; const Result: Pointer);
+procedure _LapeSameText(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := SameText(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeAnsiUpperCase(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiUpperCase(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := AnsiUpperCase(PlpString(Params^[0])^);
 end;
 
-procedure _LapeAnsiLowerCase(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiLowerCase(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := AnsiLowerCase(PlpString(Params^[0])^);
 end;
 
-procedure _LapeAnsiCompareStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiCompareStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := AnsiCompareStr(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeAnsiCompareText(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiCompareText(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := AnsiCompareText(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeAnsiSameText(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiSameText(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := AnsiSameText(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeAnsiSameStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiSameStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := AnsiSameStr(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeTrim(const Params: PParamArray; const Result: Pointer);
+procedure _LapeTrim(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := Trim(PlpString(Params^[0])^);
 end;
 
-procedure _LapeTrimLeft(const Params: PParamArray; const Result: Pointer);
+procedure _LapeTrimLeft(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := TrimLeft(PlpString(Params^[0])^);
 end;
 
-procedure _LapeTrimRight(const Params: PParamArray; const Result: Pointer);
+procedure _LapeTrimRight(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := TrimRight(PlpString(Params^[0])^);
 end;
 
-procedure _LapePadL(const Params: PParamArray; const Result: Pointer);
+procedure _LapePadL(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := StringOfChar(PlpChar(Params^[2])^, PUInt32(Params^[1])^ - Length(PlpString(Params^[0])^)) + PlpString(Params^[0])^;
 end;
 
-procedure _LapePadR(const Params: PParamArray; const Result: Pointer);
+procedure _LapePadR(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := PlpString(Params^[0])^ + StringOfChar(PlpChar(Params^[2])^, PUInt32(Params^[1])^ - Length(PlpString(Params^[0])^));
 end;
 
-procedure _LapeQuotedStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeQuotedStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := QuotedStr(PlpString(Params^[0])^);
 end;
 
-procedure _LapeAnsiQuotedStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiQuotedStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := AnsiQuotedStr(PlpString(Params^[0])^, Char(PlpChar(Params^[1])^));
 end;
 
-procedure _LapeAnsiDequotedStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAnsiDequotedStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := AnsiDequotedStr(PlpString(Params^[0])^, Char(PlpChar(Params^[1])^));
 end;
@@ -121,82 +121,82 @@ type
   TAnsiCharSet = set of AnsiChar;
   PAnsiCharSet = ^TAnsiCharSet;
 
-procedure _LapeWrapText(const Params: PParamArray; const Result: Pointer);
+procedure _LapeWrapText(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := WrapText(PlpString(Params^[0])^, PlpString(Params^[1])^, PAnsiCharSet(Params^[2])^, PInt32(Params^[3])^);
 end;
 
-procedure _LapeAdjustLineBreaks(const Params: PParamArray; const Result: Pointer);
+procedure _LapeAdjustLineBreaks(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := AdjustLineBreaks(PlpString(Params^[0])^, TTextLineBreakStyle(PLapeSmallEnum(Params^[1])^));
 end;
 
-procedure _LapeIntToHex(const Params: PParamArray; const Result: Pointer);
+procedure _LapeIntToHex(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToHex(PInt64(Params^[0])^, PInt32(Params^[1])^);
 end;
 
-procedure _LapeUIntToHex(const Params: PParamArray; const Result: Pointer);
+procedure _LapeUIntToHex(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := IntToHex(PUInt64(Params^[0])^, PInt32(Params^[1])^);
 end;
 
-procedure _LapeStrToInt(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToInt(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := StrToInt(PlpString(Params^[0])^);
 end;
 
-procedure _LapeStrToIntDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToIntDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt32(Result)^ := StrToIntDef(PlpString(Params^[0])^, PInt32(Params^[1])^);
 end;
 
-procedure _LapeStrToInt64(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToInt64(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt64(Result)^ := StrToInt64(PlpString(Params^[0])^);
 end;
 
-procedure _LapeStrToInt64Def(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToInt64Def(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PInt64(Result)^ := StrToInt64Def(PlpString(Params^[0])^, PInt64(Params^[1])^);
 end;
 
-procedure _LapeStrToUInt64(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToUInt64(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PUInt64(Result)^ := StrToUInt64(PlpString(Params^[0])^);
 end;
 
-procedure _LapeStrToUInt64Def(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToUInt64Def(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PUInt64(Result)^ := StrToUInt64Def(PlpString(Params^[0])^, PUInt64(Params^[1])^);
 end;
 
-procedure _LapeStrToFloat(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToFloat(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := StrToFloat(PlpString(Params^[0])^);
 end;
 
-procedure _LapeStrToFloatDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToFloatDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PExtended(Result)^ := StrToFloatDef(PlpString(Params^[0])^, PExtended(Params^[1])^);
 end;
 
-procedure _LapeStrToCurr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToCurr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PCurrency(Result)^ := StrToCurr(PlpString(Params^[0])^);
 end;
 
-procedure _LapeStrToCurrDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToCurrDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PCurrency(Result)^ := StrToCurrDef(PlpString(Params^[0])^, PCurrency(Params^[1])^);
 end;
 
-procedure _LapeStrToBool(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToBool(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := StrToBool(PlpString(Params^[0])^);
 end;
 
-procedure _LapeBoolToStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeBoolToStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   if PEvalBool(Params^[0])^ then
     PlpString(Result)^ := PlpString(Params^[1])^
@@ -204,12 +204,12 @@ begin
     PlpString(Result)^ := PlpString(Params^[2])^;
 end;
 
-procedure _LapeStrToBoolDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStrToBoolDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := StrToBoolDef(PlpString(Params^[0])^, PEvalBool(Params^[1])^);
 end;
 
-procedure _LapeFormat(const Params: PParamArray; const Result: Pointer);
+procedure _LapeFormat(const Params: PParamArray; const Result: Pointer); lape_extdecl
 var
   ConstArr: TVarRecList;
 begin
@@ -217,52 +217,52 @@ begin
   PlpString(Result)^ := Format(PlpString(Params^[0])^, ConstArr.VarRecs);
 end;
 
-procedure _LapeFormatFloat(const Params: PParamArray; const Result: Pointer);
+procedure _LapeFormatFloat(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := FormatFloat(PlpString(Params^[0])^, PExtended(Params^[1])^);
 end;
 
-procedure _LapeFormatCurr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeFormatCurr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := FormatCurr(PlpString(Params^[0])^, PCurrency(Params^[1])^);
 end;
 
-procedure _LapeLastDelimiter(const Params: PParamArray; const Result: Pointer);
+procedure _LapeLastDelimiter(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PSizeInt(Result)^ := LastDelimiter(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeStringReplace(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStringReplace(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := StringReplace(PlpString(Params^[0])^, PlpString(Params^[1])^, PlpString(Params^[2])^, TReplaceFlags(PLapeSmallEnum(Params^[3])^));
 end;
 
-procedure _LapeIsDelimiter(const Params: PParamArray; const Result: Pointer);
+procedure _LapeIsDelimiter(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := IsDelimiter(PlpString(Params^[0])^, PlpString(Params^[1])^, PSizeInt(Params^[2])^);
 end;
 
-procedure _LapePos(const Params: PParamArray; const Result: Pointer);
+procedure _LapePos(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PSizeInt(Result)^ := Pos(PlpString(Params^[0])^, PlpString(Params^[1])^);
 end;
 
-procedure _LapeCopy(const Params: PParamArray; const Result: Pointer);
+procedure _LapeCopy(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := Copy(PlpString(Params^[0])^, PSizeInt(Params^[1])^, PSizeInt(Params^[2])^);
 end;
 
-procedure _LapeInsert(const Params: PParamArray);
+procedure _LapeInsert(const Params: PParamArray); lape_extdecl
 begin
   Insert(PlpString(Params^[0])^, PlpString(Params^[1])^, PSizeInt(Params^[2])^);
 end;
 
-procedure _LapeDelete(const Params: PParamArray);
+procedure _LapeDelete(const Params: PParamArray); lape_extdecl
 begin
   Delete(PlpString(Params^[0])^, PSizeInt(Params^[1])^, PSizeInt(Params^[2])^);
 end;
 
-procedure _LapeStringOfChar(const Params: PParamArray; const Result: Pointer);
+procedure _LapeStringOfChar(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PlpString(Result)^ := StringOfChar(PlpChar(Params^[0])^, PSizeInt(Params^[1])^);
 end;
diff --git a/lpeval_wrappers_variant.inc b/lpeval_wrappers_variant.inc
index 1c2f308..cec8b63 100644
--- a/lpeval_wrappers_variant.inc
+++ b/lpeval_wrappers_variant.inc
@@ -9,134 +9,134 @@
 
 type
   PVarType = ^TVarType;
-procedure _LapeVarType(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarType(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVarType(Result)^ := VarType(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarAsType(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarAsType(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVariant(Result)^ := VarAsType(PVariant(Params^[0])^, PVarType(Params^[1])^);
 end;
 
-procedure _LapeVarIsByRef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsByRef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsByRef(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarIsEmpty(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsEmpty(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsEmpty(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarIsNull(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsNull(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsNull(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarIsClear(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsClear(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsClear(PVariant(Params^[0])^);
 end;
 
 type
   PRESULT = ^HRESULT;
-procedure _LapeVarIsError(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsError(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsError(PVariant(Params^[0])^, PRESULT(Params^[1])^);
 end;
 
-procedure _LapeVarAsError(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarAsError(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVariant(Result)^ := VarAsError(PRESULT(Params^[0])^);
 end;
 
-procedure _LapeVarIsCustom(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsCustom(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsCustom(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarIsOrdinal(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsOrdinal(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsOrdinal(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarIsFloat(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsFloat(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsFloat(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarIsNumeric(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsNumeric(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsNumeric(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarIsStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsStr(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarIsArray(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarIsArray(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarIsArray(PVariant(Params^[0])^, PEvalBool(Params^[1])^);
 end;
 
-procedure _LapeVarToStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarToStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PAnsiString(Result)^ := VarToStr(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarToStrDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarToStrDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PAnsiString(Result)^ := VarToStrDef(PVariant(Params^[0])^, PAnsiString(Params^[1])^);
 end;
 
-procedure _LapeVarToWideStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarToWideStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PWideString(Result)^ := VarToWideStr(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarToWideStrDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarToWideStrDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PWideString(Result)^ := VarToWideStrDef(PVariant(Params^[0])^, PWideString(Params^[1])^);
 end;
 
-procedure _LapeVarToUnicodeStr(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarToUnicodeStr(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PUnicodeString(Result)^ := {$IFDEF FPC}VarToUnicodeStr{$ELSE}VarToStr{$ENDIF}(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarToUnicodeStrDef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarToUnicodeStrDef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PUnicodeString(Result)^ := {$IFDEF FPC}VarToUnicodeStrDef{$ELSE}VarToStrDef{$ENDIF}(PVariant(Params^[0])^, PUnicodeString(Params^[1])^);
 end;
 
-procedure _LapeVarToDateTime(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarToDateTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PDateTime(Result)^ := VarToDateTime(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarFromDateTime(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarFromDateTime(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVariant(Result)^ := VarFromDateTime(PDateTime(Params^[0])^);
 end;
 
-procedure _LapeVarInRange(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarInRange(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarInRange(PVariant(Params^[0])^, PVariant(Params^[1])^, PVariant(Params^[2])^);
 end;
 
-procedure _LapeVarEnsureRange(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarEnsureRange(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVariant(Result)^ := VarEnsureRange(PVariant(Params^[0])^, PVariant(Params^[1])^, PVariant(Params^[2])^);
 end;
 
-procedure _LapeVarSameValue(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarSameValue(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarSameValue(PVariant(Params^[0])^, PVariant(Params^[1])^);
 end;
 
-procedure _LapeVarCompareValue(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarCompareValue(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PLapeSmallEnum(Result)^ := ELapeSmallEnum(VarCompareValue(PVariant(Params^[0])^, PVariant(Params^[1])^));
 end;
@@ -145,67 +145,67 @@ type
   TSizeIntArray = array of {$IFDEF FPC}SizeInt{$ELSE}Integer{$ENDIF};
   PSizeIntArray = ^TSizeIntArray;
 
-procedure _LapeVarTypeIsValidArrayType(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarTypeIsValidArrayType(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarTypeIsValidArrayType(PVarType(Params^[0])^);
 end;
 
-procedure _LapeVarTypeIsValidElementType(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarTypeIsValidElementType(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PEvalBool(Result)^ := VarTypeIsValidElementType(PVarType(Params^[0])^);
 end;
 
-procedure _LapeVarArrayCreate(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayCreate(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVariant(Result)^ := VarArrayCreate(PSizeIntArray(Params^[0])^, PVarType(Params^[1])^);
 end;
 
-procedure _LapeVarArrayOf(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayOf(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVariant(Result)^ := VarArrayOf(PVariantArray(Params^[0])^);
 end;
 
-procedure _LapeVarArrayRedim(const Params: PParamArray);
+procedure _LapeVarArrayRedim(const Params: PParamArray); lape_extdecl
 begin
   VarArrayRedim(PVariant(Params^[0])^, PSizeInt(Params^[0])^);
 end;
 
-procedure _LapeVarArrayAsPSafeArray(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayAsPSafeArray(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PPointer(Result)^ := VarArrayAsPSafeArray(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarCopyNoInd(const Params: PParamArray);
+procedure _LapeVarCopyNoInd(const Params: PParamArray); lape_extdecl
 begin
   VarCopyNoInd(PVariant(Params^[0])^, PVariant(Params^[1])^);
 end;
 
-procedure _LapeVarArrayDimCount(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayDimCount(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PSizeInt(Result)^ := VarArrayDimCount(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarArrayLowBound(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayLowBound(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PSizeInt(Result)^ := VarArrayLowBound(PVariant(Params^[0])^, PSizeInt(Params^[1])^);
 end;
 
-procedure _LapeVarArrayHighBound(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayHighBound(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PSizeInt(Result)^ := VarArrayHighBound(PVariant(Params^[0])^, PSizeInt(Params^[1])^);
 end;
 
-procedure _LapeVarArrayLock(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayLock(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PPointer(Result)^ := VarArrayLock(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarArrayUnlock(const Params: PParamArray);
+procedure _LapeVarArrayUnlock(const Params: PParamArray); lape_extdecl
 begin
   VarArrayUnlock(PVariant(Params^[0])^);
 end;
 
-procedure _LapeVarArrayRef(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayRef(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVariant(Result)^ := VarArrayRef(PVariant(Params^[0])^);
 end;
@@ -214,12 +214,12 @@ type
   TIntArray = array of Int32;
   PIntArray = ^TIntArray;
 
-procedure _LapeVarArrayGet(const Params: PParamArray; const Result: Pointer);
+procedure _LapeVarArrayGet(const Params: PParamArray; const Result: Pointer); lape_extdecl
 begin
   PVariant(Result)^ := VarArrayGet(PVariant(Params^[0])^, PIntArray(Params^[1])^);
 end;
 
-procedure _LapeVarArraySet(const Params: PParamArray);
+procedure _LapeVarArraySet(const Params: PParamArray); lape_extdecl
 begin
   VarArrayPut(PVariant(Params^[0])^, PVariant(Params^[1])^, PIntArray(Params^[2])^);
 end;
diff --git a/lptypes.pas b/lptypes.pas
index 27035b6..051c1e7 100644
--- a/lptypes.pas
+++ b/lptypes.pas
@@ -139,9 +139,9 @@ type
   PEvalBool = ^EvalBool;
 
   EMemoryPos = (mpNone, mpStack, mpMem, mpVar);
-  TLapeEvalProc = procedure(const Dest, Left, Right: Pointer);
+  TLapeEvalProc = procedure(const Dest, Left, Right: Pointer); lape_extdecl
   TLapeImportedProc = procedure(const Params: PParamArray);
-  TLapeImportedFunc = procedure(const Params: PParamArray; const Result: Pointer);
+  TLapeImportedFunc = procedure(const Params: PParamArray; const Result: Pointer); lape_extdecl
 
   ELapeBaseType = (
     ltUnknown,
@@ -2001,4 +2001,4 @@ finalization
 {$ENDIF}
 
 end.
-
+
\ No newline at end of file
-- 
1.7.3.4

