diff --git a/Blitz/BlitzPointer.decls b/Blitz/BlitzPointer.decls
index e2d70e0..1e49857 100644
--- a/Blitz/BlitzPointer.decls
+++ b/Blitz/BlitzPointer.decls
@@ -16,6 +16,11 @@
 
 .lib "BlitzPointer.dll"
 
+; BlitzPointer
+BP_GetReturnAddress%()
+BP_GetFunctionPointer%()
+BP_GetVariablePointer%()
+
 ; Memory Modification
 PeekMemoryByte%(lpMemoryPointer%)
 PeekMemoryShort%(lpMemoryPointer%)
@@ -28,372 +33,367 @@ PokeMemoryInt(lpMemoryPointer%, value%)
 PokeMemoryFloat(lpMemoryPointer%, value#)
 PokeMemory(lpMemoryPointer%, iLength%, lpBank*)
 
-; BlitzPointer
-BlitzPointer_GetReturnAddress%()
-BlitzPointer_GetFunctionPointer%()
-
 ; Function Calling
-BlitzPointer_CallFunctionV(lpFunctionPointer%) : "BlitzPointer_CallFunction0"
-BlitzPointer_CallFunctionVI(lpFunctionPointer%, P1%) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionVII(lpFunctionPointer%, p1%, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVIII(lpFunctionPointer%, p1%, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIIII(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIIIF(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIIIP(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIIF(lpFunctionPointer%, p1%, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIIFI(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIIFF(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIIFP(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIIP(lpFunctionPointer%, p1%, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIIPI(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIIPF(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIIPP(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIF(lpFunctionPointer%, p1%, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVIFI(lpFunctionPointer%, p1%, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIFII(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIFIF(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIFIP(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIFF(lpFunctionPointer%, p1%, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIFFI(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIFFF(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIFFP(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIFP(lpFunctionPointer%, p1%, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIFPI(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIFPF(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIFPP(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIP(lpFunctionPointer%, p1%, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVIPI(lpFunctionPointer%, p1%, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIPII(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIPIF(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIPIP(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIPF(lpFunctionPointer%, p1%, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIPFI(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIPFF(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIPFP(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIPP(lpFunctionPointer%, p1%, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVIPPI(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIPPF(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVIPPP(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVF(lpFunctionPointer%, P1#) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionVFI(lpFunctionPointer%, p1#, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVFII(lpFunctionPointer%, p1#, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFIII(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFIIF(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFIIP(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFIF(lpFunctionPointer%, p1#, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFIFI(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFIFF(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFIFP(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFIP(lpFunctionPointer%, p1#, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFIPI(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFIPF(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFIPP(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFF(lpFunctionPointer%, p1#, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVFFI(lpFunctionPointer%, p1#, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFFII(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFFIF(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFFIP(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFFF(lpFunctionPointer%, p1#, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFFFI(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFFFF(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFFFP(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFFP(lpFunctionPointer%, p1#, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFFPI(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFFPF(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFFPP(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFP(lpFunctionPointer%, p1#, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVFPI(lpFunctionPointer%, p1#, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFPII(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFPIF(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFPIP(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFPF(lpFunctionPointer%, p1#, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFPFI(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFPFF(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFPFP(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFPP(lpFunctionPointer%, p1#, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVFPPI(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFPPF(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVFPPP(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVP(lpFunctionPointer%, P1*) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionVPI(lpFunctionPointer%, p1*, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVPII(lpFunctionPointer%, p1*, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPIII(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPIIF(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPIIP(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPIF(lpFunctionPointer%, p1*, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPIFI(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPIFF(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPIFP(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPIP(lpFunctionPointer%, p1*, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPIPI(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPIPF(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPIPP(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPF(lpFunctionPointer%, p1*, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVPFI(lpFunctionPointer%, p1*, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPFII(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPFIF(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPFIP(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPFF(lpFunctionPointer%, p1*, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPFFI(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPFFF(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPFFP(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPFP(lpFunctionPointer%, p1*, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPFPI(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPFPF(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPFPP(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPP(lpFunctionPointer%, p1*, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionVPPI(lpFunctionPointer%, p1*, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPPII(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPPIF(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPPIP(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPPF(lpFunctionPointer%, p1*, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPPFI(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPPFF(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPPFP(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPPP(lpFunctionPointer%, p1*, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionVPPPI(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPPPF(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionVPPPP(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionI%(lpFunctionPointer%) : "BlitzPointer_CallFunction0"
-BlitzPointer_CallFunctionII%(lpFunctionPointer%, P1%) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionIII%(lpFunctionPointer%, p1%, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIIII%(lpFunctionPointer%, p1%, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIIII%(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIIIF%(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIIIP%(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIIF%(lpFunctionPointer%, p1%, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIIFI%(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIIFF%(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIIFP%(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIIP%(lpFunctionPointer%, p1%, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIIPI%(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIIPF%(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIIPP%(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIF%(lpFunctionPointer%, p1%, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIIFI%(lpFunctionPointer%, p1%, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIFII%(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIFIF%(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIFIP%(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIFF%(lpFunctionPointer%, p1%, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIFFI%(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIFFF%(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIFFP%(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIFP%(lpFunctionPointer%, p1%, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIFPI%(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIFPF%(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIFPP%(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIP%(lpFunctionPointer%, p1%, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIIPI%(lpFunctionPointer%, p1%, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIPII%(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIPIF%(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIPIP%(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIPF%(lpFunctionPointer%, p1%, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIPFI%(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIPFF%(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIPFP%(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIPP%(lpFunctionPointer%, p1%, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIIPPI%(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIPPF%(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIIPPP%(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIF%(lpFunctionPointer%, P1#) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionIFI%(lpFunctionPointer%, p1#, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIFII%(lpFunctionPointer%, p1#, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFIII%(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFIIF%(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFIIP%(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFIF%(lpFunctionPointer%, p1#, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFIFI%(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFIFF%(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFIFP%(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFIP%(lpFunctionPointer%, p1#, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFIPI%(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFIPF%(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFIPP%(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFF%(lpFunctionPointer%, p1#, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIFFI%(lpFunctionPointer%, p1#, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFFII%(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFFIF%(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFFIP%(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFFF%(lpFunctionPointer%, p1#, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFFFI%(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFFFF%(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFFFP%(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFFP%(lpFunctionPointer%, p1#, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFFPI%(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFFPF%(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFFPP%(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFP%(lpFunctionPointer%, p1#, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIFPI%(lpFunctionPointer%, p1#, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFPII%(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFPIF%(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFPIP%(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFPF%(lpFunctionPointer%, p1#, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFPFI%(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFPFF%(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFPFP%(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFPP%(lpFunctionPointer%, p1#, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIFPPI%(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFPPF%(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIFPPP%(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIP%(lpFunctionPointer%, P1*) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionIPI%(lpFunctionPointer%, p1*, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIPII%(lpFunctionPointer%, p1*, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPIII%(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPIIF%(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPIIP%(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPIF%(lpFunctionPointer%, p1*, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPIFI%(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPIFF%(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPIFP%(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPIP%(lpFunctionPointer%, p1*, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPIPI%(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPIPF%(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPIPP%(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPF%(lpFunctionPointer%, p1*, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIPFI%(lpFunctionPointer%, p1*, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPFII%(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPFIF%(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPFIP%(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPFF%(lpFunctionPointer%, p1*, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPFFI%(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPFFF%(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPFFP%(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPFP%(lpFunctionPointer%, p1*, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPFPI%(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPFPF%(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPFPP%(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPP%(lpFunctionPointer%, p1*, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionIPPI%(lpFunctionPointer%, p1*, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPPII%(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPPIF%(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPPIP%(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPPF%(lpFunctionPointer%, p1*, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPPFI%(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPPFF%(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPPFP%(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPPP%(lpFunctionPointer%, p1*, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionIPPPI%(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPPPF%(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionIPPPP%(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionF#(lpFunctionPointer%) : "BlitzPointer_CallFunction0"
-BlitzPointer_CallFunctionFI#(lpFunctionPointer%, P1%) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionFII#(lpFunctionPointer%, p1%, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFIII#(lpFunctionPointer%, p1%, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIIII#(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIIIF#(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIIIP#(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIIF#(lpFunctionPointer%, p1%, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIIFI#(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIIFF#(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIIFP#(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIIP#(lpFunctionPointer%, p1%, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIIPI#(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIIPF#(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIIPP#(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIF#(lpFunctionPointer%, p1%, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFIFI#(lpFunctionPointer%, p1%, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIFII#(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIFIF#(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIFIP#(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIFF#(lpFunctionPointer%, p1%, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIFFI#(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIFFF#(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIFFP#(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIFP#(lpFunctionPointer%, p1%, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIFPI#(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIFPF#(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIFPP#(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIP#(lpFunctionPointer%, p1%, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFIPI#(lpFunctionPointer%, p1%, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIPII#(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIPIF#(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIPIP#(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIPF#(lpFunctionPointer%, p1%, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIPFI#(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIPFF#(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIPFP#(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIPP#(lpFunctionPointer%, p1%, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFIPPI#(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIPPF#(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFIPPP#(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFF#(lpFunctionPointer%, P1#) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionFFI#(lpFunctionPointer%, p1#, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFFII#(lpFunctionPointer%, p1#, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFIII#(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFIIF#(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFIIP#(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFIF#(lpFunctionPointer%, p1#, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFIFI#(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFIFF#(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFIFP#(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFIP#(lpFunctionPointer%, p1#, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFIPI#(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFIPF#(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFIPP#(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFF#(lpFunctionPointer%, p1#, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFFFI#(lpFunctionPointer%, p1#, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFFII#(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFFIF#(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFFIP#(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFFF#(lpFunctionPointer%, p1#, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFFFI#(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFFFF#(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFFFP#(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFFP#(lpFunctionPointer%, p1#, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFFPI#(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFFPF#(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFFPP#(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFP#(lpFunctionPointer%, p1#, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFFPI#(lpFunctionPointer%, p1#, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFPII#(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFPIF#(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFPIP#(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFPF#(lpFunctionPointer%, p1#, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFPFI#(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFPFF#(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFPFP#(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFPP#(lpFunctionPointer%, p1#, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFFPPI#(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFPPF#(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFFPPP#(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFP#(lpFunctionPointer%, P1*) : "BlitzPointer_CallFunction1"
-BlitzPointer_CallFunctionFPI#(lpFunctionPointer%, p1*, p2%) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFPII#(lpFunctionPointer%, p1*, p2%, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPIII#(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPIIF#(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPIIP#(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPIF#(lpFunctionPointer%, p1*, p2%, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPIFI#(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPIFF#(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPIFP#(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPIP#(lpFunctionPointer%, p1*, p2%, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPIPI#(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPIPF#(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPIPP#(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPF#(lpFunctionPointer%, p1*, p2#) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFPFI#(lpFunctionPointer%, p1*, p2#, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPFII#(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPFIF#(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPFIP#(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPFF#(lpFunctionPointer%, p1*, p2#, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPFFI#(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPFFF#(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPFFP#(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPFP#(lpFunctionPointer%, p1*, p2#, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPFPI#(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPFPF#(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPFPP#(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPP#(lpFunctionPointer%, p1*, p2*) : "BlitzPointer_CallFunction2"
-BlitzPointer_CallFunctionFPPI#(lpFunctionPointer%, p1*, p2*, p3%) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPPII#(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPPIF#(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPPIP#(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPPF#(lpFunctionPointer%, p1*, p2*, p3#) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPPFI#(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPPFF#(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPPFP#(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPPP#(lpFunctionPointer%, p1*, p2*, p3*) : "BlitzPointer_CallFunction3"
-BlitzPointer_CallFunctionFPPPI#(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPPPF#(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionFPPPP#(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BlitzPointer_CallFunction4"
-BlitzPointer_CallFunctionS$(lpFunctionPointer%) : "BlitzPointer_CallFunctionT0"
+BP_CallFunctionV(lpFunctionPointer%) : "BP_CallFunction0"
+BP_CallFunctionVI(lpFunctionPointer%, P1%) : "BP_CallFunction1"
+BP_CallFunctionVII(lpFunctionPointer%, p1%, p2%) : "BP_CallFunction2"
+BP_CallFunctionVIII(lpFunctionPointer%, p1%, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionVIIII(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIIIF(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIIIP(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVIIF(lpFunctionPointer%, p1%, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionVIIFI(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIIFF(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIIFP(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVIIP(lpFunctionPointer%, p1%, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionVIIPI(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIIPF(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIIPP(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionVIF(lpFunctionPointer%, p1%, p2#) : "BP_CallFunction2"
+BP_CallFunctionVIFI(lpFunctionPointer%, p1%, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionVIFII(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIFIF(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIFIP(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVIFF(lpFunctionPointer%, p1%, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionVIFFI(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIFFF(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIFFP(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVIFP(lpFunctionPointer%, p1%, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionVIFPI(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIFPF(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIFPP(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionVIP(lpFunctionPointer%, p1%, p2*) : "BP_CallFunction2"
+BP_CallFunctionVIPI(lpFunctionPointer%, p1%, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionVIPII(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIPIF(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIPIP(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVIPF(lpFunctionPointer%, p1%, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionVIPFI(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIPFF(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIPFP(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVIPP(lpFunctionPointer%, p1%, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionVIPPI(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVIPPF(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVIPPP(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionVF(lpFunctionPointer%, P1#) : "BP_CallFunction1"
+BP_CallFunctionVFI(lpFunctionPointer%, p1#, p2%) : "BP_CallFunction2"
+BP_CallFunctionVFII(lpFunctionPointer%, p1#, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionVFIII(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFIIF(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFIIP(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVFIF(lpFunctionPointer%, p1#, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionVFIFI(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFIFF(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFIFP(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVFIP(lpFunctionPointer%, p1#, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionVFIPI(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFIPF(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFIPP(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionVFF(lpFunctionPointer%, p1#, p2#) : "BP_CallFunction2"
+BP_CallFunctionVFFI(lpFunctionPointer%, p1#, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionVFFII(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFFIF(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFFIP(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVFFF(lpFunctionPointer%, p1#, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionVFFFI(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFFFF(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFFFP(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVFFP(lpFunctionPointer%, p1#, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionVFFPI(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFFPF(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFFPP(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionVFP(lpFunctionPointer%, p1#, p2*) : "BP_CallFunction2"
+BP_CallFunctionVFPI(lpFunctionPointer%, p1#, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionVFPII(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFPIF(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFPIP(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVFPF(lpFunctionPointer%, p1#, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionVFPFI(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFPFF(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFPFP(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVFPP(lpFunctionPointer%, p1#, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionVFPPI(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVFPPF(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVFPPP(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionVP(lpFunctionPointer%, P1*) : "BP_CallFunction1"
+BP_CallFunctionVPI(lpFunctionPointer%, p1*, p2%) : "BP_CallFunction2"
+BP_CallFunctionVPII(lpFunctionPointer%, p1*, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionVPIII(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPIIF(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPIIP(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVPIF(lpFunctionPointer%, p1*, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionVPIFI(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPIFF(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPIFP(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVPIP(lpFunctionPointer%, p1*, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionVPIPI(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPIPF(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPIPP(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionVPF(lpFunctionPointer%, p1*, p2#) : "BP_CallFunction2"
+BP_CallFunctionVPFI(lpFunctionPointer%, p1*, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionVPFII(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPFIF(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPFIP(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVPFF(lpFunctionPointer%, p1*, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionVPFFI(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPFFF(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPFFP(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVPFP(lpFunctionPointer%, p1*, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionVPFPI(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPFPF(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPFPP(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionVPP(lpFunctionPointer%, p1*, p2*) : "BP_CallFunction2"
+BP_CallFunctionVPPI(lpFunctionPointer%, p1*, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionVPPII(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPPIF(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPPIP(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionVPPF(lpFunctionPointer%, p1*, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionVPPFI(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPPFF(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPPFP(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionVPPP(lpFunctionPointer%, p1*, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionVPPPI(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionVPPPF(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionVPPPP(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionI%(lpFunctionPointer%) : "BP_CallFunction0"
+BP_CallFunctionII%(lpFunctionPointer%, P1%) : "BP_CallFunction1"
+BP_CallFunctionIII%(lpFunctionPointer%, p1%, p2%) : "BP_CallFunction2"
+BP_CallFunctionIIII%(lpFunctionPointer%, p1%, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionIIIII%(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIIIF%(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIIIP%(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIIIF%(lpFunctionPointer%, p1%, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionIIIFI%(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIIFF%(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIIFP%(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIIIP%(lpFunctionPointer%, p1%, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionIIIPI%(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIIPF%(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIIPP%(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionIIF%(lpFunctionPointer%, p1%, p2#) : "BP_CallFunction2"
+BP_CallFunctionIIFI%(lpFunctionPointer%, p1%, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionIIFII%(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIFIF%(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIFIP%(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIIFF%(lpFunctionPointer%, p1%, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionIIFFI%(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIFFF%(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIFFP%(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIIFP%(lpFunctionPointer%, p1%, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionIIFPI%(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIFPF%(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIFPP%(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionIIP%(lpFunctionPointer%, p1%, p2*) : "BP_CallFunction2"
+BP_CallFunctionIIPI%(lpFunctionPointer%, p1%, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionIIPII%(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIPIF%(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIPIP%(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIIPF%(lpFunctionPointer%, p1%, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionIIPFI%(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIPFF%(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIPFP%(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIIPP%(lpFunctionPointer%, p1%, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionIIPPI%(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIIPPF%(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIIPPP%(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionIF%(lpFunctionPointer%, P1#) : "BP_CallFunction1"
+BP_CallFunctionIFI%(lpFunctionPointer%, p1#, p2%) : "BP_CallFunction2"
+BP_CallFunctionIFII%(lpFunctionPointer%, p1#, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionIFIII%(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFIIF%(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFIIP%(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIFIF%(lpFunctionPointer%, p1#, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionIFIFI%(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFIFF%(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFIFP%(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIFIP%(lpFunctionPointer%, p1#, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionIFIPI%(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFIPF%(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFIPP%(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionIFF%(lpFunctionPointer%, p1#, p2#) : "BP_CallFunction2"
+BP_CallFunctionIFFI%(lpFunctionPointer%, p1#, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionIFFII%(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFFIF%(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFFIP%(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIFFF%(lpFunctionPointer%, p1#, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionIFFFI%(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFFFF%(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFFFP%(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIFFP%(lpFunctionPointer%, p1#, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionIFFPI%(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFFPF%(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFFPP%(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionIFP%(lpFunctionPointer%, p1#, p2*) : "BP_CallFunction2"
+BP_CallFunctionIFPI%(lpFunctionPointer%, p1#, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionIFPII%(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFPIF%(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFPIP%(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIFPF%(lpFunctionPointer%, p1#, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionIFPFI%(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFPFF%(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFPFP%(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIFPP%(lpFunctionPointer%, p1#, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionIFPPI%(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIFPPF%(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIFPPP%(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionIP%(lpFunctionPointer%, P1*) : "BP_CallFunction1"
+BP_CallFunctionIPI%(lpFunctionPointer%, p1*, p2%) : "BP_CallFunction2"
+BP_CallFunctionIPII%(lpFunctionPointer%, p1*, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionIPIII%(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPIIF%(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPIIP%(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIPIF%(lpFunctionPointer%, p1*, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionIPIFI%(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPIFF%(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPIFP%(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIPIP%(lpFunctionPointer%, p1*, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionIPIPI%(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPIPF%(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPIPP%(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionIPF%(lpFunctionPointer%, p1*, p2#) : "BP_CallFunction2"
+BP_CallFunctionIPFI%(lpFunctionPointer%, p1*, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionIPFII%(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPFIF%(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPFIP%(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIPFF%(lpFunctionPointer%, p1*, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionIPFFI%(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPFFF%(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPFFP%(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIPFP%(lpFunctionPointer%, p1*, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionIPFPI%(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPFPF%(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPFPP%(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionIPP%(lpFunctionPointer%, p1*, p2*) : "BP_CallFunction2"
+BP_CallFunctionIPPI%(lpFunctionPointer%, p1*, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionIPPII%(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPPIF%(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPPIP%(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionIPPF%(lpFunctionPointer%, p1*, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionIPPFI%(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPPFF%(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPPFP%(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionIPPP%(lpFunctionPointer%, p1*, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionIPPPI%(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionIPPPF%(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionIPPPP%(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionF#(lpFunctionPointer%) : "BP_CallFunction0"
+BP_CallFunctionFI#(lpFunctionPointer%, P1%) : "BP_CallFunction1"
+BP_CallFunctionFII#(lpFunctionPointer%, p1%, p2%) : "BP_CallFunction2"
+BP_CallFunctionFIII#(lpFunctionPointer%, p1%, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionFIIII#(lpFunctionPointer%, p1%, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIIIF#(lpFunctionPointer%, p1%, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIIIP#(lpFunctionPointer%, p1%, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFIIF#(lpFunctionPointer%, p1%, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionFIIFI#(lpFunctionPointer%, p1%, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIIFF#(lpFunctionPointer%, p1%, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIIFP#(lpFunctionPointer%, p1%, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFIIP#(lpFunctionPointer%, p1%, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionFIIPI#(lpFunctionPointer%, p1%, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIIPF#(lpFunctionPointer%, p1%, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIIPP#(lpFunctionPointer%, p1%, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionFIF#(lpFunctionPointer%, p1%, p2#) : "BP_CallFunction2"
+BP_CallFunctionFIFI#(lpFunctionPointer%, p1%, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionFIFII#(lpFunctionPointer%, p1%, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIFIF#(lpFunctionPointer%, p1%, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIFIP#(lpFunctionPointer%, p1%, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFIFF#(lpFunctionPointer%, p1%, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionFIFFI#(lpFunctionPointer%, p1%, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIFFF#(lpFunctionPointer%, p1%, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIFFP#(lpFunctionPointer%, p1%, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFIFP#(lpFunctionPointer%, p1%, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionFIFPI#(lpFunctionPointer%, p1%, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIFPF#(lpFunctionPointer%, p1%, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIFPP#(lpFunctionPointer%, p1%, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionFIP#(lpFunctionPointer%, p1%, p2*) : "BP_CallFunction2"
+BP_CallFunctionFIPI#(lpFunctionPointer%, p1%, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionFIPII#(lpFunctionPointer%, p1%, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIPIF#(lpFunctionPointer%, p1%, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIPIP#(lpFunctionPointer%, p1%, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFIPF#(lpFunctionPointer%, p1%, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionFIPFI#(lpFunctionPointer%, p1%, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIPFF#(lpFunctionPointer%, p1%, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIPFP#(lpFunctionPointer%, p1%, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFIPP#(lpFunctionPointer%, p1%, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionFIPPI#(lpFunctionPointer%, p1%, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFIPPF#(lpFunctionPointer%, p1%, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFIPPP#(lpFunctionPointer%, p1%, p2*, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionFF#(lpFunctionPointer%, P1#) : "BP_CallFunction1"
+BP_CallFunctionFFI#(lpFunctionPointer%, p1#, p2%) : "BP_CallFunction2"
+BP_CallFunctionFFII#(lpFunctionPointer%, p1#, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionFFIII#(lpFunctionPointer%, p1#, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFIIF#(lpFunctionPointer%, p1#, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFIIP#(lpFunctionPointer%, p1#, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFFIF#(lpFunctionPointer%, p1#, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionFFIFI#(lpFunctionPointer%, p1#, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFIFF#(lpFunctionPointer%, p1#, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFIFP#(lpFunctionPointer%, p1#, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFFIP#(lpFunctionPointer%, p1#, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionFFIPI#(lpFunctionPointer%, p1#, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFIPF#(lpFunctionPointer%, p1#, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFIPP#(lpFunctionPointer%, p1#, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionFFF#(lpFunctionPointer%, p1#, p2#) : "BP_CallFunction2"
+BP_CallFunctionFFFI#(lpFunctionPointer%, p1#, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionFFFII#(lpFunctionPointer%, p1#, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFFIF#(lpFunctionPointer%, p1#, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFFIP#(lpFunctionPointer%, p1#, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFFFF#(lpFunctionPointer%, p1#, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionFFFFI#(lpFunctionPointer%, p1#, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFFFF#(lpFunctionPointer%, p1#, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFFFP#(lpFunctionPointer%, p1#, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFFFP#(lpFunctionPointer%, p1#, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionFFFPI#(lpFunctionPointer%, p1#, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFFPF#(lpFunctionPointer%, p1#, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFFPP#(lpFunctionPointer%, p1#, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionFFP#(lpFunctionPointer%, p1#, p2*) : "BP_CallFunction2"
+BP_CallFunctionFFPI#(lpFunctionPointer%, p1#, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionFFPII#(lpFunctionPointer%, p1#, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFPIF#(lpFunctionPointer%, p1#, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFPIP#(lpFunctionPointer%, p1#, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFFPF#(lpFunctionPointer%, p1#, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionFFPFI#(lpFunctionPointer%, p1#, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFPFF#(lpFunctionPointer%, p1#, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFPFP#(lpFunctionPointer%, p1#, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFFPP#(lpFunctionPointer%, p1#, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionFFPPI#(lpFunctionPointer%, p1#, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFFPPF#(lpFunctionPointer%, p1#, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFFPPP#(lpFunctionPointer%, p1#, p2*, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionFP#(lpFunctionPointer%, P1*) : "BP_CallFunction1"
+BP_CallFunctionFPI#(lpFunctionPointer%, p1*, p2%) : "BP_CallFunction2"
+BP_CallFunctionFPII#(lpFunctionPointer%, p1*, p2%, p3%) : "BP_CallFunction3"
+BP_CallFunctionFPIII#(lpFunctionPointer%, p1*, p2%, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPIIF#(lpFunctionPointer%, p1*, p2%, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPIIP#(lpFunctionPointer%, p1*, p2%, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFPIF#(lpFunctionPointer%, p1*, p2%, p3#) : "BP_CallFunction3"
+BP_CallFunctionFPIFI#(lpFunctionPointer%, p1*, p2%, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPIFF#(lpFunctionPointer%, p1*, p2%, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPIFP#(lpFunctionPointer%, p1*, p2%, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFPIP#(lpFunctionPointer%, p1*, p2%, p3*) : "BP_CallFunction3"
+BP_CallFunctionFPIPI#(lpFunctionPointer%, p1*, p2%, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPIPF#(lpFunctionPointer%, p1*, p2%, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPIPP#(lpFunctionPointer%, p1*, p2%, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionFPF#(lpFunctionPointer%, p1*, p2#) : "BP_CallFunction2"
+BP_CallFunctionFPFI#(lpFunctionPointer%, p1*, p2#, p3%) : "BP_CallFunction3"
+BP_CallFunctionFPFII#(lpFunctionPointer%, p1*, p2#, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPFIF#(lpFunctionPointer%, p1*, p2#, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPFIP#(lpFunctionPointer%, p1*, p2#, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFPFF#(lpFunctionPointer%, p1*, p2#, p3#) : "BP_CallFunction3"
+BP_CallFunctionFPFFI#(lpFunctionPointer%, p1*, p2#, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPFFF#(lpFunctionPointer%, p1*, p2#, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPFFP#(lpFunctionPointer%, p1*, p2#, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFPFP#(lpFunctionPointer%, p1*, p2#, p3*) : "BP_CallFunction3"
+BP_CallFunctionFPFPI#(lpFunctionPointer%, p1*, p2#, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPFPF#(lpFunctionPointer%, p1*, p2#, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPFPP#(lpFunctionPointer%, p1*, p2#, p3*, p4*) : "BP_CallFunction4"
+BP_CallFunctionFPP#(lpFunctionPointer%, p1*, p2*) : "BP_CallFunction2"
+BP_CallFunctionFPPI#(lpFunctionPointer%, p1*, p2*, p3%) : "BP_CallFunction3"
+BP_CallFunctionFPPII#(lpFunctionPointer%, p1*, p2*, p3%, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPPIF#(lpFunctionPointer%, p1*, p2*, p3%, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPPIP#(lpFunctionPointer%, p1*, p2*, p3%, p4*) : "BP_CallFunction4"
+BP_CallFunctionFPPF#(lpFunctionPointer%, p1*, p2*, p3#) : "BP_CallFunction3"
+BP_CallFunctionFPPFI#(lpFunctionPointer%, p1*, p2*, p3#, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPPFF#(lpFunctionPointer%, p1*, p2*, p3#, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPPFP#(lpFunctionPointer%, p1*, p2*, p3#, p4*) : "BP_CallFunction4"
+BP_CallFunctionFPPP#(lpFunctionPointer%, p1*, p2*, p3*) : "BP_CallFunction3"
+BP_CallFunctionFPPPI#(lpFunctionPointer%, p1*, p2*, p3*, p4%) : "BP_CallFunction4"
+BP_CallFunctionFPPPF#(lpFunctionPointer%, p1*, p2*, p3*, p4#) : "BP_CallFunction4"
+BP_CallFunctionFPPPP#(lpFunctionPointer%, p1*, p2*, p3*, p4*) : "BP_CallFunction4"
diff --git a/Blitz/Example01.bb b/Blitz/Example01.bb
index e6220a2..630660f 100644
--- a/Blitz/Example01.bb
+++ b/Blitz/Example01.bb
@@ -38,14 +38,14 @@ Global fpOurFunction = 0
 
 ; Our function can be anything we want, however we must be able to call it once
 ;  without effect before we can actually retrieve the function pointer. Why?
-; Simple! The BlitzPointer_GetFunctionPointer traces the return address for the
+; Simple! The BP_GetFunctionPointer traces the return address for the
 ;  Blitz function signature - and thus can't work outside a function.
 Function OurFunction()
 ;	Let's begin by checking if we already have the pointer. Not required, but
 ;	 we do it anyway to save some scanning time on every call.
 	If fpOurFunction = 0 Then
 ;		Now let us call the above mentioned function to retrieve the pointer.
-		fpOurFunction = BlitzPointer_GetFunctionPointer()
+		fpOurFunction = BP_GetFunctionPointer()
 ;		Weether you use a Return or an Else is up to you. Return is technically
 ;		 faster in Blitz, as using Else causes a complex ASM construction.
 		Return
diff --git a/Blitz/Example02.bb b/Blitz/Example02.bb
index 98bfd54..8478909 100644
--- a/Blitz/Example02.bb
+++ b/Blitz/Example02.bb
@@ -29,7 +29,7 @@ ExampleInit()
 Global fpOurFunction = 0
 Function OurFunction()
 	If fpOurFunction = 0 Then
-		fpOurFunction = BlitzPointer_GetFunctionPointer()
+		fpOurFunction = BP_GetFunctionPointer()
 		Return
 	EndIf
 	
@@ -44,7 +44,7 @@ While Not KeyHit(1)
 ;   BlitzPointer offers many ways of calling our function pointer. Each one
 ;    describes different return types, parameter count and parameter types. 
 ;   Let's use the one that doesn't return a value for now.
-	BlitzPointer_CallFunctionV fpOurFunction
+	BP_CallFunctionV fpOurFunction
 ;   Now if we run the program, instead of a fixed native call, we're calling a
 ;    function pointer instead. Pretty useful in my opinion, especially for UI,
 ;    networking, fake classes, etc.
diff --git a/Blitz/Example03.bb b/Blitz/Example03.bb
index 3412334..e2edacb 100644
--- a/Blitz/Example03.bb
+++ b/Blitz/Example03.bb
@@ -29,9 +29,9 @@
 ; ---------------------------------------------------------------------------- ;
 ;  Type    Id  Description      Calling Function
 ; ---------------------------------------------------------------------------- ;
-;   void	V	Nothing          BlitzPointer_CallFunctionV
-;   int		I	32-bit Integer   BlitzPointer_CallFunctionI
-;   float	F	Floating Point   BlitzPointer_CallFunctionF
+;   void	V	Nothing          BP_CallFunctionV
+;   int		I	32-bit Integer   BP_CallFunctionI
+;   float	F	Floating Point   BP_CallFunctionF
 
 ; Now that we know what we can and can't do (without memory leaks at least),
 ;  let's try out the return types ourselves.
@@ -43,7 +43,7 @@ ExampleInit()
 Global fpVoidFunction = 0
 Function VoidFunction()
 	If fpVoidFunction = 0 Then
-		fpVoidFunction = BlitzPointer_GetFunctionPointer()
+		fpVoidFunction = BP_GetFunctionPointer()
 		Return
 	EndIf
 	Text 0, 0, "Void Return Type"
@@ -54,7 +54,7 @@ VoidFunction()
 Global fpIntFunction = 0
 Function IntFunction%()
 	If fpIntFunction = 0 Then
-		fpIntFunction = BlitzPointer_GetFunctionPointer()
+		fpIntFunction = BP_GetFunctionPointer()
 		Return
 	EndIf
 	Text   0, 15, "Int Return Type"
@@ -66,7 +66,7 @@ IntFunction()
 Global fpFloatFunction = 0
 Function FloatFunction#()
 	If fpFloatFunction = 0 Then
-		fpFloatFunction = BlitzPointer_GetFunctionPointer()
+		fpFloatFunction = BP_GetFunctionPointer()
 		Return
 	EndIf
 	Text    0, 30, "Float Return Type"
@@ -78,9 +78,9 @@ While Not KeyHit(1)
 	ExampleUpdate()
 	
 ;	Calling the function and using the return value is really easy to do now:
-	BlitzPointer_CallFunctionV(fpVoidFunction)		; void returns nothing.
-	Text 200, 15, BlitzPointer_CallFunctionI(fpIntFunction)
-	Text 200, 30, BlitzPointer_CallFunctionF(fpFloatFunction)
+	BP_CallFunctionV(fpVoidFunction)		; void returns nothing.
+	Text 200, 15, BP_CallFunctionI(fpIntFunction)
+	Text 200, 30, BP_CallFunctionF(fpFloatFunction)
 	
 	ExampleLoop()
 Wend
diff --git a/Blitz/Example04.bb b/Blitz/Example04.bb
index 07f7e83..5dbfef1 100644
--- a/Blitz/Example04.bb
+++ b/Blitz/Example04.bb
@@ -31,9 +31,9 @@
 ; ---------------------------------------------------------------------------- ;
 ;  Type    Id  Description      Calling Function
 ; ---------------------------------------------------------------------------- ;
-;   int     I   32-bit Integer   BlitzPointer_CallFunction*I
-;   float   F   Floating Point   BlitzPointer_CallFunction*F
-;   pointer P   Memory Pointer   BlitzPointer_CallFunction*P
+;   int     I   32-bit Integer   BP_CallFunction*I
+;   float   F   Floating Point   BP_CallFunction*F
+;   pointer P   Memory Pointer   BP_CallFunction*P
 
 ; Watch out:
 ;  Calling a function that has parameters without giving enough parameters will
@@ -47,7 +47,7 @@ ExampleInit()
 Global fpCurInGameSecond = 0
 Function CurInGameSecond%(p1%=0)
 	If fpCurInGameSecond = 0 Then
-		fpCurInGameSecond = BlitzPointer_GetFunctionPointer()
+		fpCurInGameSecond = BP_GetFunctionPointer()
 		Return
 	EndIf
 	Text   5, 15, "IIFunction"
@@ -61,7 +61,7 @@ CurInGameSecond()
 Global fpCurInGameSecondEx = 0
 Function CurInGameSecondEx#(p1%=0, p2#=0)
 	If fpCurInGameSecondEx = 0 Then
-		fpCurInGameSecondEx = BlitzPointer_GetFunctionPointer()
+		fpCurInGameSecondEx = BP_GetFunctionPointer()
 		Return
 	EndIf
 	
@@ -78,7 +78,7 @@ CurInGameSecondEx()
 Global fpConvertIntFloat
 Function ConvertIntFloat#(p1#=0)
 	If fpConvertIntFloat = 0 Then
-		fpConvertIntFloat = BlitzPointer_GetFunctionPointer()
+		fpConvertIntFloat = BP_GetFunctionPointer()
 		Print Hex(fpConvertIntFloat)
 		WaitKey()
 		Return
@@ -101,18 +101,18 @@ While Not KeyHit(1)
 	Text 480, 0, "Parameter 4"
 	Text 600, 0, "Result"
 	
-	Text 605, 15, BlitzPointer_CallFunctionII(fpCurInGameSecond, Frame)
-	Text 605, 30, BlitzPointer_CallFunctionFIF(fpCurInGameSecondEx, Frame, 0.016666666)
+	Text 605, 15, BP_CallFunctionII(fpCurInGameSecond, Frame)
+	Text 605, 30, BP_CallFunctionFIF(fpCurInGameSecondEx, Frame, 0.016666666)
 	
 	Local TempFlt# = Frame / 60.0
-	Local TempInt% = BlitzPointer_CallFunctionIF(fpConvertIntFloat, TempFlt)
+	Local TempInt% = BP_CallFunctionIF(fpConvertIntFloat, TempFlt)
 	Text   5, 60, "Float -> Int"
 	Text 125, 60, TempFlt
 	Text 605, 60, Hex(TempInt)
 	
 	Text   5, 75, "Int -> Float"
 	Text 125, 75, Hex(TempInt)
-	Text 605, 75, BlitzPointer_CallFunctionFI(fpConvertIntFloat, TempInt)
+	Text 605, 75, BP_CallFunctionFI(fpConvertIntFloat, TempInt)
 	
 	ExampleLoop()
 	
diff --git a/Blitz/Example05.bb b/Blitz/Example05.bb
index 4ae5d72..b8cf68b 100644
--- a/Blitz/Example05.bb
+++ b/Blitz/Example05.bb
@@ -41,7 +41,7 @@ End Type
 Global fpMyTypeFunc = 0
 Function MyTypeFunc(This.MyType)
 	If fpMyTypeFunc = 0 Then
-		fpMyTypeFunc = BlitzPointer_GetFunctionPointer()
+		fpMyTypeFunc = BP_GetFunctionPointer()
 		Return
 	EndIf
 	If This = Null Then Return
@@ -64,8 +64,8 @@ While Not KeyHit(1)
 	
 ;    Now in order to pass a Type Object to a function, we have to get a pointer
 ;     from it. Thankfully, Blitz has this already built in: Int().
-	If KeyDown(2) Then BlitzPointer_CallFunctionVI fpMyTypeFunc, Int(MT1)
-	If KeyDown(3) Then BlitzPointer_CallFunctionVI fpMyTypeFunc, Int(MT2)
+	If KeyDown(2) Then BP_CallFunctionVI fpMyTypeFunc, Int(MT1)
+	If KeyDown(3) Then BP_CallFunctionVI fpMyTypeFunc, Int(MT2)
 	
 	ExampleLoop()
 Wend
diff --git a/Blitz/Example06.bb b/Blitz/Example06.bb
index 616fa3f..bdf8067 100644
--- a/Blitz/Example06.bb
+++ b/Blitz/Example06.bb
@@ -82,7 +82,7 @@ End Type
 Global fpMyPointerFunction% = 0
 Function MyPointerFunction(Pointer%)
 	If fpMyPointerFunction = 0 Then
-		fpMyPointerFunction = BlitzPointer_GetFunctionPointer()
+		fpMyPointerFunction = BP_GetFunctionPointer()
 		Return
 	EndIf
 	
diff --git a/Blitz/Example07.bb b/Blitz/Example07.bb
index f839e10..fda4700 100644
--- a/Blitz/Example07.bb
+++ b/Blitz/Example07.bb
@@ -54,7 +54,7 @@ Function TGenericUpdate()
 	Local This.TGeneric
 	For This = Each TGeneric
 		If This\Pointer <> 0 Then
-			If BlitzPointer_CallFunctionII(CallbackIndex(This\Index), This\Pointer) Then
+			If BP_CallFunctionII(CallbackIndex(This\Index), This\Pointer) Then
 				Delete This
 			EndIf
 		EndIf
@@ -98,7 +98,7 @@ End Function
 
 Function TCubeCallback%(This.TCube)
 	If CallbackIndex(CALLBACK_INDEX_TCUBE) = 0 Then
-		CallbackIndex(CALLBACK_INDEX_TCUBE) = BlitzPointer_GetFunctionPointer()
+		CallbackIndex(CALLBACK_INDEX_TCUBE) = BP_GetFunctionPointer()
 		Return
 	EndIf
 	; Safeguard against stupidity (it affect everyone).
@@ -156,7 +156,7 @@ End Function
 
 Function TSphereUpdate%(This.TSphere)
 	If CallbackIndex(CALLBACK_INDEX_TSPHERE) = 0 Then
-		CallbackIndex(CALLBACK_INDEX_TSPHERE) = BlitzPointer_GetFunctionPointer()
+		CallbackIndex(CALLBACK_INDEX_TSPHERE) = BP_GetFunctionPointer()
 		Return
 	EndIf
 	; Safeguard against stupidity (it affect everyone).
diff --git a/BlitzHybrid.cpp b/BlitzHybrid.cpp
deleted file mode 100644
index 06765e6..0000000
--- a/BlitzHybrid.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//	BlitzPointer - Adding Pointers to Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "BlitzPointer.h"
-
-// Hybrid specific defines.
-#define CALLFUNCTION_DECL_BEGIN_64(NAME)				DLL_EXPORT int64_t BlitzPointer_CallFunction##NAME(intptr_t lpFunctionPointer
-#define CALLFUNCTION_IMPL_PARAMETER_64(INDEX, NAME)		__asm MOV RAX, [NAME] __asm mov [esp + INDEX * 4], RAX
-#define CALLFUNCTION_IMPL_CALL_64()						__asm CALL QWORD ptr[lpFunctionPointer]
-#define CALLFUNCTION_IMPL_RESULT_64()					int64_t result; __asm MOV [result], RAX
-
-/*
-// No Parameters
-CALLFUNCTION_DECL_BEGIN_64(Q0)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-	CALLFUNCTION_IMPL_SAFEGUARD()
-	CALLFUNCTION_IMPL_CALL_64()
-	CALLFUNCTION_IMPL_RESULT_64()
-	CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-// One Parameter
-CALLFUNCTION_DECL_BEGIN_64(Q1D)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p1)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-	CALLFUNCTION_IMPL_SAFEGUARD()
-	CALLFUNCTION_IMPL_PREPARE(1)
-	CALLFUNCTION_IMPL_PARAMETER(0, p1)
-	CALLFUNCTION_IMPL_CALL_64()
-	CALLFUNCTION_IMPL_RESULT_64()
-	CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-CALLFUNCTION_DECL_BEGIN_64(Q1Q)
-	CALLFUNCTION_DECL_PARAMETER(int64_t, p1)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-	CALLFUNCTION_IMPL_SAFEGUARD()
-	CALLFUNCTION_IMPL_PREPARE(1)
-	CALLFUNCTION_IMPL_PARAMETER_64(0, p1)
-	CALLFUNCTION_IMPL_CALL_64()
-	CALLFUNCTION_IMPL_RESULT_64()
-	CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-// Two Parameters
-CALLFUNCTION_DECL_BEGIN(D2DQ)
-CALLFUNCTION_DECL_PARAMETER(int32_t, p1)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p2)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-CALLFUNCTION_IMPL_SAFEGUARD()
-CALLFUNCTION_IMPL_PREPARE(2)
-CALLFUNCTION_IMPL_PARAMETER_64(1, p2)
-CALLFUNCTION_IMPL_PARAMETER(0, p1)
-CALLFUNCTION_IMPL_CALL()
-CALLFUNCTION_IMPL_RESULT()
-CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-CALLFUNCTION_DECL_BEGIN(D2QD)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p1)
-CALLFUNCTION_DECL_PARAMETER(int32_t, p2)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-CALLFUNCTION_IMPL_SAFEGUARD()
-CALLFUNCTION_IMPL_PREPARE(2)
-CALLFUNCTION_IMPL_PARAMETER(1, p2)
-CALLFUNCTION_IMPL_PARAMETER_64(0, p1)
-CALLFUNCTION_IMPL_CALL()
-CALLFUNCTION_IMPL_RESULT()
-CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-CALLFUNCTION_DECL_BEGIN(D2QQ)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p1)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p2)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-CALLFUNCTION_IMPL_SAFEGUARD()
-CALLFUNCTION_IMPL_PREPARE(2)
-CALLFUNCTION_IMPL_PARAMETER_64(1, p2)
-CALLFUNCTION_IMPL_PARAMETER_64(0, p1)
-CALLFUNCTION_IMPL_CALL()
-CALLFUNCTION_IMPL_RESULT()
-CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-CALLFUNCTION_DECL_BEGIN_64(Q2DD)
-CALLFUNCTION_DECL_PARAMETER(int32_t, p1)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p2)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-CALLFUNCTION_IMPL_SAFEGUARD()
-CALLFUNCTION_IMPL_PREPARE(2)
-CALLFUNCTION_IMPL_PARAMETER_64(1, p2)
-CALLFUNCTION_IMPL_PARAMETER(0, p1)
-CALLFUNCTION_IMPL_CALL()
-CALLFUNCTION_IMPL_RESULT_64()
-CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-CALLFUNCTION_DECL_BEGIN_64(Q2DQ)
-CALLFUNCTION_DECL_PARAMETER(int32_t, p1)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p2)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-CALLFUNCTION_IMPL_SAFEGUARD()
-CALLFUNCTION_IMPL_PREPARE(2)
-CALLFUNCTION_IMPL_PARAMETER_64(1, p2)
-CALLFUNCTION_IMPL_PARAMETER(0, p1)
-CALLFUNCTION_IMPL_CALL()
-CALLFUNCTION_IMPL_RESULT_64()
-CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-CALLFUNCTION_DECL_BEGIN_64(Q2QD)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p1)
-CALLFUNCTION_DECL_PARAMETER(int32_t, p2)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-CALLFUNCTION_IMPL_SAFEGUARD()
-CALLFUNCTION_IMPL_PREPARE(2)
-CALLFUNCTION_IMPL_PARAMETER(1, p2)
-CALLFUNCTION_IMPL_PARAMETER_64(0, p1)
-CALLFUNCTION_IMPL_CALL()
-CALLFUNCTION_IMPL_RESULT_64()
-CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-CALLFUNCTION_DECL_BEGIN_64(Q2QQ)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p1)
-CALLFUNCTION_DECL_PARAMETER(int64_t, p2)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-CALLFUNCTION_IMPL_SAFEGUARD()
-CALLFUNCTION_IMPL_PREPARE(2)
-CALLFUNCTION_IMPL_PARAMETER_64(1, p2)
-CALLFUNCTION_IMPL_PARAMETER_64(0, p1)
-CALLFUNCTION_IMPL_CALL()
-CALLFUNCTION_IMPL_RESULT_64()
-CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-
-*/
\ No newline at end of file
diff --git a/BlitzNative.cpp b/BlitzNative.cpp
deleted file mode 100644
index 0591240..0000000
--- a/BlitzNative.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//	BlitzPointer - Adding Pointers to Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "BlitzPointer.h"
-
-// No Parameters
-CALLFUNCTION_DECL_BEGIN(0)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-	CALLFUNCTION_IMPL_SAFEGUARD()
-	CALLFUNCTION_IMPL_CALL()
-	CALLFUNCTION_IMPL_RESULT()
-	CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction0=_BlitzPointer_CallFunction0@4")
-
-// One Parameter
-CALLFUNCTION_DECL_BEGIN(1)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p1)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-	CALLFUNCTION_IMPL_SAFEGUARD()
-	CALLFUNCTION_IMPL_PREPARE(1)
-	CALLFUNCTION_IMPL_PARAMETER(0, p1)
-	CALLFUNCTION_IMPL_CALL()
-	CALLFUNCTION_IMPL_RESULT()
-	CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction1=_BlitzPointer_CallFunction1@8")
-
-// Two Parameters
-CALLFUNCTION_DECL_BEGIN(2)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p1)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p2)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-	CALLFUNCTION_IMPL_SAFEGUARD()
-	CALLFUNCTION_IMPL_PREPARE(2)
-	CALLFUNCTION_IMPL_PARAMETER(1, p2)
-	CALLFUNCTION_IMPL_PARAMETER(0, p1)
-	CALLFUNCTION_IMPL_CALL()
-	CALLFUNCTION_IMPL_RESULT()
-	CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction2=_BlitzPointer_CallFunction2@12")
-
-// Three Parameters
-CALLFUNCTION_DECL_BEGIN(3)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p1)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p2)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p3)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-	CALLFUNCTION_IMPL_SAFEGUARD()
-	CALLFUNCTION_IMPL_PREPARE(3)
-	CALLFUNCTION_IMPL_PARAMETER(2, p3)
-	CALLFUNCTION_IMPL_PARAMETER(1, p2)
-	CALLFUNCTION_IMPL_PARAMETER(0, p1)
-	CALLFUNCTION_IMPL_CALL()
-	CALLFUNCTION_IMPL_RESULT()
-	CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction3=_BlitzPointer_CallFunction3@16")
-
-// Four Parameters
-CALLFUNCTION_DECL_BEGIN(4)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p1)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p2)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p3)
-	CALLFUNCTION_DECL_PARAMETER(int32_t, p4)
-CALLFUNCTION_DECL_END() CALLFUNCTION_IMPL_BEGIN()
-	CALLFUNCTION_IMPL_SAFEGUARD()
-	CALLFUNCTION_IMPL_PREPARE(4)
-	CALLFUNCTION_IMPL_PARAMETER(3, p4)
-	CALLFUNCTION_IMPL_PARAMETER(2, p3)
-	CALLFUNCTION_IMPL_PARAMETER(1, p2)
-	CALLFUNCTION_IMPL_PARAMETER(0, p1)
-	CALLFUNCTION_IMPL_CALL()
-	CALLFUNCTION_IMPL_RESULT()
-	CALLFUNCTION_IMPL_RETURN()
-CALLFUNCTION_IMPL_END()
-#pragma comment(linker, "/EXPORT:BlitzPointer_CallFunction4=_BlitzPointer_CallFunction4@20")
diff --git a/BlitzPointer.cpp b/BlitzPointer.cpp
index 4fc8de3..43c4544 100644
--- a/BlitzPointer.cpp
+++ b/BlitzPointer.cpp
@@ -19,7 +19,7 @@
 
 #include "BlitzPointer.h"
 
-DLL_EXPORT intptr_t BlitzPointer_GetReturnAddress() {
+DLL_METHOD intptr_t DLL_CALL BP_GetReturnAddress() {
 	intptr_t StackPointer, ReturnAddress;
 
 	__asm { //ASM. Do touch if suicidal.
@@ -32,9 +32,9 @@ DLL_EXPORT intptr_t BlitzPointer_GetReturnAddress() {
 
 	return ReturnAddress;
 }
-#pragma comment(linker, "/EXPORT:BlitzPointer_GetReturnAddress=_BlitzPointer_GetReturnAddress@0")
+#pragma comment(linker, "/EXPORT:BP_GetReturnAddress=_BP_GetReturnAddress@0")
 
-DLL_EXPORT intptr_t BlitzPointer_GetFunctionPointer()
+DLL_METHOD intptr_t DLL_CALL BP_GetFunctionPointer()
 {
 	intptr_t StackPointer, ReturnAddress;
 
@@ -60,4 +60,37 @@ DLL_EXPORT intptr_t BlitzPointer_GetFunctionPointer()
 
 	return 0;
 }
-#pragma comment(linker, "/EXPORT:BlitzPointer_GetFunctionPointer=_BlitzPointer_GetFunctionPointer@0")
+#pragma comment(linker, "/EXPORT:BP_GetFunctionPointer=_BP_GetFunctionPointer@0")
+
+DLL_METHOD intptr_t DLL_CALL BP_GetVariablePointer() {
+	// ToDo: Figure out how to get the pointer of a variable reliably. Must do so without Goto.
+	// - Idea: Have user assign variable to the ptr first? Easier to find.
+	// - Strings are difficult - exclude these?
+	return 0;
+}
+#pragma comment(linker, "/EXPORT:BP_GetVariablePointer=_BP_GetVariablePointer@0")
+
+DLL_METHOD int32_t DLL_CALL BP_CallFunction0(BP_BlitzFunction0_t lpFunctionPointer) {
+	return lpFunctionPointer();
+}
+#pragma comment(linker, "/EXPORT:BP_CallFunction0=_BP_CallFunction0@4")
+
+DLL_METHOD int32_t DLL_CALL BP_CallFunction1(BP_BlitzFunction1_t lpFunctionPointer, int32_t p1) {
+	return lpFunctionPointer(p1);
+}
+#pragma comment(linker, "/EXPORT:BP_CallFunction1=_BP_CallFunction1@8")
+
+DLL_METHOD int32_t DLL_CALL BP_CallFunction2(BP_BlitzFunction2_t lpFunctionPointer, int32_t p1, int32_t p2) {
+	return lpFunctionPointer(p1, p2);
+}
+#pragma comment(linker, "/EXPORT:BP_CallFunction2=_BP_CallFunction2@12")
+
+DLL_METHOD int32_t DLL_CALL BP_CallFunction3(BP_BlitzFunction3_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3) {
+	return lpFunctionPointer(p1, p2, p3);
+}
+#pragma comment(linker, "/EXPORT:BP_CallFunction3=_BP_CallFunction3@16")
+
+DLL_METHOD int32_t DLL_CALL BP_CallFunction4(BP_BlitzFunction4_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3, int32_t p4) {
+	return lpFunctionPointer(p1, p2, p3, p4);
+}
+#pragma comment(linker, "/EXPORT:BP_CallFunction4=_BP_CallFunction4@20")
diff --git a/BlitzPointer.h b/BlitzPointer.h
index ec8c003..39ab146 100644
--- a/BlitzPointer.h
+++ b/BlitzPointer.h
@@ -18,18 +18,21 @@
 #include "dllmain.h"
 #include <string>
 
-DLL_EXPORT intptr_t BlitzPointer_GetReturnAddress();
-DLL_EXPORT intptr_t BlitzPointer_GetFunctionPointer();
+// Types of Blitz Functions.
+typedef int32_t(__stdcall *BP_BlitzFunction0_t)();
+typedef int32_t(__stdcall *BP_BlitzFunction1_t)(int32_t);
+typedef int32_t(__stdcall *BP_BlitzFunction2_t)(int32_t, int32_t);
+typedef int32_t(__stdcall *BP_BlitzFunction3_t)(int32_t, int32_t, int32_t);
+typedef int32_t(__stdcall *BP_BlitzFunction4_t)(int32_t, int32_t, int32_t, int32_t);
 
-// Defines for easier function generation.
-#define CALLFUNCTION_DECL_BEGIN(NAME)					DLL_EXPORT int32_t BlitzPointer_CallFunction##NAME(intptr_t lpFunctionPointer
-#define CALLFUNCTION_DECL_PARAMETER(TYPE, NAME)			, TYPE NAME
-#define CALLFUNCTION_DECL_END()							)
-#define CALLFUNCTION_IMPL_BEGIN()						{ 
-#define CALLFUNCTION_IMPL_SAFEGUARD()					if (!lpFunctionPointer) return NULL;
-#define CALLFUNCTION_IMPL_PREPARE(COUNT)				__asm SUB ESP, COUNT * 4
-#define CALLFUNCTION_IMPL_PARAMETER(INDEX, NAME)		__asm MOV EAX, [NAME] __asm MOV [ESP + INDEX * 4], EAX
-#define CALLFUNCTION_IMPL_CALL()						__asm CALL DWORD ptr[lpFunctionPointer]
-#define CALLFUNCTION_IMPL_RESULT()						int32_t result; __asm MOV [result], EAX
-#define CALLFUNCTION_IMPL_RETURN()						return result; 
-#define CALLFUNCTION_IMPL_END()							}
+// Basic Functionality (Pointer retrieval)
+DLL_METHOD intptr_t DLL_CALL BP_GetReturnAddress();
+DLL_METHOD intptr_t DLL_CALL BP_GetFunctionPointer();
+DLL_METHOD intptr_t DLL_CALL BP_GetVariablePointer();
+
+// Native Blitz Function Calls
+DLL_METHOD int32_t DLL_CALL BP_CallFunction0(BP_BlitzFunction0_t lpFunctionPointer);
+DLL_METHOD int32_t DLL_CALL BP_CallFunction1(BP_BlitzFunction1_t lpFunctionPointer, int32_t p1);
+DLL_METHOD int32_t DLL_CALL BP_CallFunction2(BP_BlitzFunction2_t lpFunctionPointer, int32_t p1, int32_t p2);
+DLL_METHOD int32_t DLL_CALL BP_CallFunction3(BP_BlitzFunction3_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3);
+DLL_METHOD int32_t DLL_CALL BP_CallFunction4(BP_BlitzFunction4_t lpFunctionPointer, int32_t p1, int32_t p2, int32_t p3, int32_t p4);
diff --git a/BlitzPointer.vcxproj b/BlitzPointer.vcxproj
index 9c429c4..cf7e1e9 100644
--- a/BlitzPointer.vcxproj
+++ b/BlitzPointer.vcxproj
@@ -77,7 +77,7 @@
       <PreprocessKeepComments>false</PreprocessKeepComments>
       <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
       <OmitFramePointers>false</OmitFramePointers>
-      <CallingConvention>StdCall</CallingConvention>
+      <CallingConvention>Cdecl</CallingConvention>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -112,7 +112,7 @@
       <MinimalRebuild>false</MinimalRebuild>
       <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
       <OmitFramePointers>false</OmitFramePointers>
-      <CallingConvention>StdCall</CallingConvention>
+      <CallingConvention>Cdecl</CallingConvention>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>false</GenerateDebugInformation>
@@ -126,11 +126,6 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="BlitzHybrid.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
-    </ClCompile>
-    <ClCompile Include="BlitzNative.cpp" />
     <ClCompile Include="BlitzPointer.cpp" />
     <ClCompile Include="dllmain.cpp" />
     <ClCompile Include="MemoryHelpers.cpp" />
@@ -138,6 +133,10 @@
   <ItemGroup>
     <ClInclude Include="BlitzPointer.h" />
     <ClInclude Include="dllmain.h" />
+    <ClInclude Include="Include\BlitzPointer.h">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="LICENSE">
diff --git a/BlitzPointer.vcxproj.filters b/BlitzPointer.vcxproj.filters
index 7c9d04e..f4cde68 100644
--- a/BlitzPointer.vcxproj.filters
+++ b/BlitzPointer.vcxproj.filters
@@ -9,6 +9,10 @@
       <UniqueIdentifier>{53eae672-7e3f-4de4-af1f-79e46e407a39}</UniqueIdentifier>
       <ParseFiles>false</ParseFiles>
     </Filter>
+    <Filter Include="Include Files">
+      <UniqueIdentifier>{2651cf83-130d-4638-b631-b6321e4865d3}</UniqueIdentifier>
+      <ParseFiles>false</ParseFiles>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="dllmain.cpp">
@@ -17,12 +21,6 @@
     <ClCompile Include="BlitzPointer.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="BlitzNative.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="BlitzHybrid.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="MemoryHelpers.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -34,6 +32,9 @@
     <ClInclude Include="BlitzPointer.h">
       <Filter>Source Files</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BlitzPointer.h">
+      <Filter>Include Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="Blitz\Example05.bb">
@@ -66,5 +67,7 @@
     <None Include="Blitz\Example07.bb">
       <Filter>Blitz Files</Filter>
     </None>
+    <None Include="LICENSE" />
+    <None Include="LICENSE.lesser" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/MemoryHelpers.cpp b/MemoryHelpers.cpp
index d7f6ca5..d2ea2f5 100644
--- a/MemoryHelpers.cpp
+++ b/MemoryHelpers.cpp
@@ -16,7 +16,7 @@
 
 #include "dllmain.h"
 
-DLL_EXPORT uint32_t PeekMemory(uint32_t* address, uint32_t length, intptr_t bank) {
+DLL_METHOD uint32_t DLL_CALL PeekMemory(uint32_t* address, uint32_t length, intptr_t bank) {
 	uint32_t bankAddress, bankSize;
 	bankAddress = *(uint32_t*)(bank + 4);
 	bankSize = *(uint32_t*)(bank + 8);
@@ -32,7 +32,7 @@ DLL_EXPORT uint32_t PeekMemory(uint32_t* address, uint32_t length, intptr_t bank
 }
 #pragma comment(linker, "/EXPORT:PeekMemory=_PeekMemory@12")
 
-DLL_EXPORT uint32_t PokeMemory(uint32_t address, uint32_t length, intptr_t bank) {
+DLL_METHOD uint32_t DLL_CALL PokeMemory(uint32_t address, uint32_t length, intptr_t bank) {
 	uint32_t bankAddress, bankSize;
 	bankAddress = *(uint32_t*)(bank + 4);
 	bankSize = *(uint32_t*)(bank + 8);
@@ -48,42 +48,42 @@ DLL_EXPORT uint32_t PokeMemory(uint32_t address, uint32_t length, intptr_t bank)
 }
 #pragma comment(linker, "/EXPORT:PokeMemory=_PokeMemory@12")
 
-DLL_EXPORT int8_t PeekMemoryByte(uint32_t* address) {
+DLL_METHOD int8_t DLL_CALL PeekMemoryByte(uint32_t* address) {
 	return *(int8_t*)address;
 }
 #pragma comment(linker, "/EXPORT:PeekMemoryByte=_PeekMemoryByte@4")
 
-DLL_EXPORT void PokeMemoryByte(uint32_t* address, int8_t value) {
+DLL_METHOD void DLL_CALL PokeMemoryByte(uint32_t* address, int8_t value) {
 	*(int8_t*)address = value;
 }
 #pragma comment(linker, "/EXPORT:PokeMemoryByte=_PokeMemoryByte@8")
 
-DLL_EXPORT int16_t PeekMemoryShort(uint32_t* address) {
+DLL_METHOD int16_t DLL_CALL PeekMemoryShort(uint32_t* address) {
 	return *(int16_t*)address;
 }
 #pragma comment(linker, "/EXPORT:PeekMemoryShort=_PeekMemoryShort@4")
 
-DLL_EXPORT void PokeMemoryShort(uint32_t* address, int16_t value) {
+DLL_METHOD void DLL_CALL PokeMemoryShort(uint32_t* address, int16_t value) {
 	*(int16_t*)address = value;
 }
 #pragma comment(linker, "/EXPORT:PokeMemoryShort=_PokeMemoryShort@8")
 
-DLL_EXPORT int32_t PeekMemoryInt(uint32_t* address) {
+DLL_METHOD int32_t DLL_CALL PeekMemoryInt(uint32_t* address) {
 	return *(int32_t*)address;
 }
 #pragma comment(linker, "/EXPORT:PeekMemoryInt=_PeekMemoryInt@4")
 
-DLL_EXPORT void PokeMemoryInt(uint32_t* address, int32_t value) {
+DLL_METHOD void DLL_CALL PokeMemoryInt(uint32_t* address, int32_t value) {
 	*(int32_t*)address = value;
 }
 #pragma comment(linker, "/EXPORT:PokeMemoryInt=_PokeMemoryInt@8")
 
-DLL_EXPORT float_t PeekMemoryFloat(uint32_t* address) {
+DLL_METHOD float_t DLL_CALL PeekMemoryFloat(uint32_t* address) {
 	return *(float_t*)address;
 }
 #pragma comment(linker, "/EXPORT:PeekMemoryFloat=_PeekMemoryFloat@4")
 
-DLL_EXPORT void PokeMemoryFloat(uint32_t* address, float_t value) {
+DLL_METHOD void DLL_CALL PokeMemoryFloat(uint32_t* address, float_t value) {
 	*(float_t*)address = value;
 }
 #pragma comment(linker, "/EXPORT:PokeMemoryFloat=_PokeMemoryFloat@8")
diff --git a/dllmain.h b/dllmain.h
index 0873944..a521e27 100644
--- a/dllmain.h
+++ b/dllmain.h
@@ -14,9 +14,7 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-// STL Exceptions
-#include <exception>
-#include <stdexcept>
+#pragma once
 
 // Memory Management
 #include <memory>
@@ -25,4 +23,9 @@
 #include <windows.h>
 
 // Macros
-#define DLL_EXPORT extern "C" //__declspec(dllexport)
\ No newline at end of file
+#ifndef IMPORT
+#define DLL_METHOD extern "C" //__declspec(dllexport)
+#else
+#define DLL_METHOD extern "c" __declspec(dllimport)
+#endif
+#define DLL_CALL __stdcall
\ No newline at end of file