Some refactor on wrapped lib handling, to limit calloc/free used and get more straight forward usage of native wrapped functions (ported from box86)

94 files changed, 503 insertions, 3433 deletions

diff --git a/src/include/box64context.h b/src/include/box64context.h
index 371fdce3..1a4fd077 100755
--- a/src/include/box64context.h
+++ b/src/include/box64context.h
@@ -140,14 +140,6 @@ typedef struct box64context_s {
     void*               sdl2freerw;
     library_t           *sdl2mixerlib;
     library_t           *x11lib;
-    library_t           *libxcb;
-    library_t           *libxcbxfixes;
-    library_t           *libxcbshape;
-    library_t           *libxcbshm;
-    library_t           *libxcbrandr;
-    library_t           *libxcbimage;
-    library_t           *libxcbkeysyms;
-    library_t           *libxcbxtest;
     library_t           *zlib;
     library_t           *vorbisfile;
     library_t           *vorbis;
diff --git a/src/include/wrappedlibs.h b/src/include/wrappedlibs.h
index f78dcfb2..d593f3f4 100755
--- a/src/include/wrappedlibs.h
+++ b/src/include/wrappedlibs.h
@@ -4,11 +4,16 @@
 
 typedef struct library_s library_t;
 typedef struct box64context_s  box64context_t;
+typedef struct wlib_s wlib_t;
 
 typedef int (*wrappedlib_init_t)(library_t * lib, box64context_t* box64);  // 0 = success
 typedef void (*wrappedlib_fini_t)(library_t * lib);
 typedef int (*wrappedlib_get_t)(library_t* lib, const char* name, uintptr_t *offs, uintptr_t *sz, int version, const char* vername, int local);
 
+void setNeededLibs(wlib_t* wlib, int n, ...);
+#define SETALT(A)       lib->altmy = strdup(#A)
+#define SETALTPREFIX(A) lib->priv.w.altprefix = strdup(A)
+
 typedef struct wrappedlib_s {
     const char*         name;
     wrappedlib_init_t   init;
diff --git a/src/librarian/library.c b/src/librarian/library.c
index 208ca4fe..8f9731c2 100755
--- a/src/librarian/library.c
+++ b/src/librarian/library.c
@@ -10,6 +10,7 @@
 #include <unistd.h>
 #include <errno.h>
 #include <link.h>
+#include <stdarg.h>
 
 #include "debug.h"
 #include "library.h"
@@ -923,3 +924,15 @@ void AddMainElfToLinkmap(elfheader_t* elf)
     lm->l_name = my_context->fullpath;
     lm->l_ld = GetDynamicSection(elf);
 }
+
+void setNeededLibs(wlib_t* wlib, int n, ...)
+{
+    wlib->needed = n;
+    wlib->neededlibs = (char**)calloc(n, sizeof(char*));
+    va_list va;
+    va_start (va, n);
+    for (int i=0; i<n; ++i) {
+        wlib->neededlibs[i] = strdup(va_arg(va, char*));
+    }
+    va_end (va);
+}
\ No newline at end of file
diff --git a/src/librarian/library_private.h b/src/librarian/library_private.h
index 9e1d3381..ebe4d027 100755
--- a/src/librarian/library_private.h
+++ b/src/librarian/library_private.h
@@ -35,7 +35,6 @@ typedef struct wlib_s {
     bridge_t        *bridge;
     void*           lib;        // dlopen result
     void*           priv;       // actual private
-    void*           p2;         // second private
     void*           box64lib;   // ref to the dlopen on box64 itself from context
     char*           altprefix;  // if function names are mangled..
     int             needed;
diff --git a/src/wrapped/wrappedalure.c b/src/wrapped/wrappedalure.c
index 761651a8..f3d216c6 100755
--- a/src/wrapped/wrappedalure.c
+++ b/src/wrapped/wrappedalure.c
@@ -15,9 +15,7 @@ const char* alureName = "libalure.so.1";
 #define LIBNAME alure
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libopenal.so.1");
+    setNeededLibs(&lib->priv.w, 1, "libopenal.so.1");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedalut.c b/src/wrapped/wrappedalut.c
index c3846ef2..cb0f2d2e 100755
--- a/src/wrapped/wrappedalut.c
+++ b/src/wrapped/wrappedalut.c
@@ -15,9 +15,7 @@ const char* alutName = "libalut.so.0";
 #define LIBNAME alut
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libopenal.so.1");
+    setNeededLibs(&lib->priv.w, 1, "libopenal.so.1");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedatk.c b/src/wrapped/wrappedatk.c
index a7150d5b..d3fe8a78 100755
--- a/src/wrapped/wrappedatk.c
+++ b/src/wrapped/wrappedatk.c
@@ -20,34 +20,10 @@
 
 const char* atkName = "libatk-1.0.so.0";
 #define LIBNAME atk
-static library_t* my_lib = NULL;
 
 #include "generated/wrappedatktypes.h"
 
-typedef struct atk_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} atk_my_t;
-
-void* getAtkMy(library_t* lib)
-{
-    my_lib = lib;
-    atk_my_t* my = (atk_my_t*)calloc(1, sizeof(atk_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeAtkMy(void* lib)
-{
-    my_lib = NULL;
-    (void)lib;
-    //atk_my_t *my = (atk_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -127,22 +103,16 @@ static void* find_AtkKeySnoopFunc_Fct(void* fct)
 
 EXPORT void my_atk_focus_tracker_init(x64emu_t* emu, void* f)
 {
-    atk_my_t *my = (atk_my_t*)my_lib->priv.w.p2;
-
     my->atk_focus_tracker_init(find_AtkEventListenerInit_Fct(f));
 }
 
 EXPORT uint32_t my_atk_add_focus_tracker(x64emu_t* emu, void* f)
 {
-    atk_my_t *my = (atk_my_t*)my_lib->priv.w.p2;
-
     return my->atk_add_focus_tracker(find_AtkEventListener_Fct(f));
 }
 
 EXPORT uint32_t my_atk_add_key_event_listener(x64emu_t* emu, void* f, void* p)
 {
-    atk_my_t *my = (atk_my_t*)my_lib->priv.w.p2;
-
     return my->atk_add_key_event_listener(find_AtkEventListener_Fct(f), p);
 }
 
@@ -151,11 +121,9 @@ EXPORT uint32_t my_atk_add_key_event_listener(x64emu_t* emu, void* f, void* p)
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getAtkMy(lib); \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeAtkMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);       \
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedatkbridge.c b/src/wrapped/wrappedatkbridge.c
index a061fd95..22d94742 100755
--- a/src/wrapped/wrappedatkbridge.c
+++ b/src/wrapped/wrappedatkbridge.c
@@ -20,12 +20,11 @@ const char* atkbridgeName = "libatk-bridge-2.0.so.0";
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 5;                                                     \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libatk-1.0.so.0");                      \
-    lib->priv.w.neededlibs[1] = strdup("libSM.so.6");                           \
-    lib->priv.w.neededlibs[2] = strdup("libICE.so.6");                          \
-    lib->priv.w.neededlibs[3] = strdup("libXau.so.6");                          \
-    lib->priv.w.neededlibs[4] = strdup("libxcb.so.1");                          \
+    setNeededLibs(&lib->priv.w, 5,      \
+        "libatk-1.0.so.0",              \
+        "libSM.so.6",                   \
+        "libICE.so.6",                  \
+        "libXau.so.6",                  \
+        "libxcb.so.1");
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedbz2.c b/src/wrapped/wrappedbz2.c
index faf81726..a5b0e5ae 100755
--- a/src/wrapped/wrappedbz2.c
+++ b/src/wrapped/wrappedbz2.c
@@ -20,32 +20,10 @@
 
 const char* bz2Name = "libbz2.so.1";
 #define LIBNAME bz2
-static library_t* my_lib = NULL;
 
 #include "generated/wrappedbz2types.h"
 
-typedef struct bz2_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} bz2_my_t;
-
-void* getBz2My(library_t* lib)
-{
-    bz2_my_t* my = (bz2_my_t*)calloc(1, sizeof(bz2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeBz2My(void* lib)
-{
-    (void)lib;
-    //bz2_my_t *my = (bz2_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -150,8 +128,6 @@ typedef struct {
 EXPORT int my_BZ2_bzCompressInit(x64emu_t* emu, my_bz_stream_t* strm, int blocksize, int verbosity, int work)
 {
     (void)emu;
-    library_t * lib = GetLibInternal(bz2Name);
-    bz2_my_t *my = (bz2_my_t*)lib->priv.w.p2;
     WRAP_BZ(strm);
     int ret = my->BZ2_bzCompressInit(strm, blocksize, verbosity, work);
     UNWRAP_BZ(strm);
@@ -161,8 +137,6 @@ EXPORT int my_BZ2_bzCompressInit(x64emu_t* emu, my_bz_stream_t* strm, int blocks
 EXPORT int my_BZ2_bzCompress(x64emu_t* emu, my_bz_stream_t* strm, int action)
 {
     (void)emu;
-    library_t * lib = GetLibInternal(bz2Name);
-    bz2_my_t *my = (bz2_my_t*)lib->priv.w.p2;
     WRAP_BZ(strm);
     int ret = my->BZ2_bzCompress(strm, action);
     UNWRAP_BZ(strm);
@@ -172,8 +146,6 @@ EXPORT int my_BZ2_bzCompress(x64emu_t* emu, my_bz_stream_t* strm, int action)
 EXPORT int my_BZ2_bzCompressEnd(x64emu_t* emu, my_bz_stream_t* strm)
 {
     (void)emu;
-    library_t * lib = GetLibInternal(bz2Name);
-    bz2_my_t *my = (bz2_my_t*)lib->priv.w.p2;
     WRAP_BZ(strm);
     int ret = my->BZ2_bzCompressEnd(strm);
     UNWRAP_BZ(strm);
@@ -183,8 +155,6 @@ EXPORT int my_BZ2_bzCompressEnd(x64emu_t* emu, my_bz_stream_t* strm)
 EXPORT int my_BZ2_bzDecompressInit(x64emu_t* emu, my_bz_stream_t* strm, int verbosity, int small)
 {
     (void)emu;
-    library_t * lib = GetLibInternal(bz2Name);
-    bz2_my_t *my = (bz2_my_t*)lib->priv.w.p2;
     WRAP_BZ(strm);
     int ret = my->BZ2_bzDecompressInit(strm, verbosity, small);
     UNWRAP_BZ(strm);
@@ -194,8 +164,6 @@ EXPORT int my_BZ2_bzDecompressInit(x64emu_t* emu, my_bz_stream_t* strm, int verb
 EXPORT int my_BZ2_bzDecompress(x64emu_t* emu, my_bz_stream_t* strm)
 {
     (void)emu;
-    library_t * lib = GetLibInternal(bz2Name);
-    bz2_my_t *my = (bz2_my_t*)lib->priv.w.p2;
     WRAP_BZ(strm);
     int ret = my->BZ2_bzDecompress(strm);
     UNWRAP_BZ(strm);
@@ -205,8 +173,6 @@ EXPORT int my_BZ2_bzDecompress(x64emu_t* emu, my_bz_stream_t* strm)
 EXPORT int my_BZ2_bzDecompressEnd(x64emu_t* emu, my_bz_stream_t* strm)
 {
     (void)emu;
-    library_t * lib = GetLibInternal(bz2Name);
-    bz2_my_t *my = (bz2_my_t*)lib->priv.w.p2;
     WRAP_BZ(strm);
     int ret = my->BZ2_bzDecompressEnd(strm);
     UNWRAP_BZ(strm);
@@ -214,12 +180,9 @@ EXPORT int my_BZ2_bzDecompressEnd(x64emu_t* emu, my_bz_stream_t* strm)
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getBz2My(lib); \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeBz2My(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedcrypto.c b/src/wrapped/wrappedcrypto.c
index b94f0a30..b84added 100755
--- a/src/wrapped/wrappedcrypto.c
+++ b/src/wrapped/wrappedcrypto.c
@@ -23,32 +23,9 @@ const char* cryptoName = "libcrypto.so.1.0.0";
 #define ALTNAME "libcrypto.so.1.0.2"
 #define ALTNAME2 "libcrypto.so.1.1"
 
-static library_t* my_lib = NULL;
-
 #include "generated/wrappedcryptotypes.h"
 
-typedef struct crypto_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} crypto_my_t;
-
-void* getCryptoMy(library_t* lib)
-{
-    crypto_my_t* my = (crypto_my_t*)calloc(1, sizeof(crypto_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeCryptoMy(void* lib)
-{
-    (void)lib;
-    //crypto_my_t *my = (crypto_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 // utility functions
 #define SUPER() \
@@ -207,115 +184,97 @@ static void* find_passphrase_Fct(void* fct)
 EXPORT int32_t my_ENGINE_ctrl(x64emu_t* emu, void* e, int32_t cmd, int32_t i, void* p, void* f)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     return my->ENGINE_ctrl(e, cmd, i, p, find_ENGINE_ctrl_cb_Fct(f));
 }
 
 EXPORT int32_t my_ENGINE_ctrl_cmd(x64emu_t* emu, void* e, void* cmd, long i, void* p, void* f, int optional)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     return my->ENGINE_ctrl_cmd(e, cmd, i, p, find_ENGINE_ctrl_cb_Fct(f), optional);
 }
 
 EXPORT void my_CRYPTO_set_id_callback(x64emu_t* emu, void* cb)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->CRYPTO_set_id_callback(find_id_func_Fct(cb));
 }
 
 EXPORT void my_CRYPTO_set_locking_callback(x64emu_t* emu, void* cb)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->CRYPTO_set_locking_callback(find_lock_func_Fct(cb));
 }
 
 EXPORT void my_PEM_read_bio_DSAPrivateKey(x64emu_t* emu, void* bp, void* x, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->PEM_read_bio_DSAPrivateKey(bp, x, find_passphrase_Fct(cb), u);
 }
 
 EXPORT void my_PEM_read_bio_DSA_PUBKEY(x64emu_t* emu, void* bp, void* x, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->PEM_read_bio_DSA_PUBKEY(bp, x, find_passphrase_Fct(cb), u);
 }
 
 EXPORT void my_PEM_read_bio_RSAPrivateKey(x64emu_t* emu, void* bp, void* x, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->PEM_read_bio_RSAPrivateKey(bp, x, find_passphrase_Fct(cb), u);
 }
 
 EXPORT void my_PEM_read_bio_RSA_PUBKEY(x64emu_t* emu, void* bp, void* x, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->PEM_read_bio_RSA_PUBKEY(bp, x, find_passphrase_Fct(cb), u);
 }
 
 EXPORT void my_PEM_read_bio_ECPrivateKey(x64emu_t* emu, void* bp, void* x, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->PEM_read_bio_ECPrivateKey(bp, x, find_passphrase_Fct(cb), u);
 }
 
 EXPORT void my_PEM_read_bio_EC_PUBKEY(x64emu_t* emu, void* bp, void* x, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->PEM_read_bio_EC_PUBKEY(bp, x, find_passphrase_Fct(cb), u);
 }
 
 EXPORT int my_PEM_write_bio_DSAPrivateKey(x64emu_t* emu, void* bp, void* x, void* e, void* str, int len, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     return my->PEM_write_bio_DSAPrivateKey(bp, x, e, str, len, find_passphrase_Fct(cb), u);
 }
 
 EXPORT int my_PEM_write_bio_RSAPrivateKey(x64emu_t* emu, void* bp, void* x, void* e, void* str, int len, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     return my->PEM_write_bio_RSAPrivateKey(bp, x, e, str, len, find_passphrase_Fct(cb), u);
 }
 
 EXPORT int my_PEM_write_bio_ECPrivateKey(x64emu_t* emu, void* bp, void* x, void* e, void* str, int len, void* cb, void* u)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     return my->PEM_write_bio_ECPrivateKey(bp, x, e, str, len, find_passphrase_Fct(cb), u);
 }
 
 EXPORT void* my_sk_new(x64emu_t* emu, void* f)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     return my->sk_new(find_cmp_fnc_Fct(f));
 }
 
 EXPORT void my_sk_pop_free(x64emu_t* emu, void* st, void* f)
 {
     (void)emu;
-    crypto_my_t *my = (crypto_my_t*)my_lib->priv.w.p2;
     my->sk_pop_free(st, find_free_fnc_Fct(f));
 }
 
 #define CUSTOM_INIT \
-    my_lib = lib;   \
-    lib->priv.w.p2 = getCryptoMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    my_lib = NULL;  \
-    freeCryptoMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedcurl.c b/src/wrapped/wrappedcurl.c
index 8bec144d..e9dc02fb 100755
--- a/src/wrapped/wrappedcurl.c
+++ b/src/wrapped/wrappedcurl.c
@@ -20,33 +20,9 @@ const char* curlName = "libcurl.so.4";
 #define ALTNAME "libcurl-gnutls.so.4"
 #define LIBNAME curl
 
-static library_t* my_lib = NULL;
-
 #include "generated/wrappedcurltypes.h"
 
-typedef struct curl_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} curl_my_t;
-
-void* getCurlMy(library_t* lib)
-{
-    curl_my_t* my = (curl_my_t*)calloc(1, sizeof(curl_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-
-    return my;
-}
-
-void freeCurlMy(void* lib)
-{
-    (void)lib;
-//    curl_my_t *my = (curl_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define LONG          0
 #define OBJECTPOINT   10000
@@ -507,7 +483,6 @@ static void* find_progress_int_Fct(void* fct)
 EXPORT uint32_t my_curl_easy_setopt(x64emu_t* emu, void* handle, uint32_t option, void* param)
 {
     (void)emu;
-    curl_my_t *my = (curl_my_t*)my_lib->priv.w.p2;
 
     switch(option) {
         case CURLOPT_WRITEDATA:
@@ -569,12 +544,9 @@ EXPORT uint32_t my_curl_easy_setopt(x64emu_t* emu, void* handle, uint32_t option
 
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getCurlMy(lib);    \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeCurlMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappeddbus.c b/src/wrapped/wrappeddbus.c
index f2910741..384c0d79 100755
--- a/src/wrapped/wrappeddbus.c
+++ b/src/wrapped/wrappeddbus.c
@@ -21,32 +21,10 @@
 
 const char* dbusName = "libdbus-1.so.3";
 #define LIBNAME dbus
-static library_t* my_lib = NULL;
 
 #include "generated/wrappeddbustypes.h"
 
-typedef struct dbus_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} dbus_my_t;
-
-static void* getDBusMy(library_t* lib)
-{
-    dbus_my_t* my = (dbus_my_t*)calloc(1, sizeof(dbus_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-static void freeDBusMy(void* lib)
-{
-    (void)lib;
-    //dbus_my_t *my = (dbus_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define NF 4
 #define SUPER() \
@@ -376,7 +354,6 @@ static void* finddbus_internal_padFct(void* fct)
 EXPORT void my_dbus_timeout_set_data(x64emu_t* emu, void* e, void* p, void* f)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
     my->dbus_timeout_set_data(e, p, find_DBusFreeFunction_Fct(f));
 }
 
@@ -384,8 +361,6 @@ EXPORT void my_dbus_timeout_set_data(x64emu_t* emu, void* e, void* p, void* f)
 EXPORT int32_t my_dbus_connection_set_timeout_functions(x64emu_t* emu, void* c, void* a, void* r, void* t, void* d, void* f)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     return my->dbus_connection_set_timeout_functions(c, 
             find_DBusAddTimeoutFunction_Fct(a), 
             find_DBusRemoveTimeoutFunction_Fct(r), 
@@ -396,21 +371,18 @@ EXPORT int32_t my_dbus_connection_set_timeout_functions(x64emu_t* emu, void* c,
 EXPORT int my_dbus_connection_add_filter(x64emu_t* emu, void* connection, void* fnc, void* data, void* fr)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
     return my->dbus_connection_add_filter(connection, find_DBusHandleMessageFunction_Fct(fnc), data, find_DBusFreeFunction_Fct(fr));
 }
 
 EXPORT void my_dbus_connection_remove_filter(x64emu_t* emu, void* connection, void* fnc, void* data)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
     my->dbus_connection_remove_filter(connection, find_DBusHandleMessageFunction_Fct(fnc), data);
 }
 
 EXPORT int my_dbus_message_get_args_valist(x64emu_t* emu, void* message, void* e, int arg, x64_va_list_t b)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -422,8 +394,6 @@ EXPORT int my_dbus_message_get_args_valist(x64emu_t* emu, void* message, void* e
 EXPORT int my_dbus_message_get_args(x64emu_t* emu, void* message, void* e, int arg, uint64_t* V)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     CREATE_VALIST_FROM_VAARG(V, emu->scratch, 3);
     return my->dbus_message_get_args_valist(message, e, arg, VARARGS);
 }
@@ -431,7 +401,6 @@ EXPORT int my_dbus_message_get_args(x64emu_t* emu, void* message, void* e, int a
 EXPORT int my_dbus_message_append_args_valist(x64emu_t* emu, void* message, int arg, x64_va_list_t b)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -443,8 +412,6 @@ EXPORT int my_dbus_message_append_args_valist(x64emu_t* emu, void* message, int
 EXPORT int my_dbus_message_append_args(x64emu_t* emu, void* message, int arg, uint64_t* V)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     CREATE_VALIST_FROM_VAARG(V, emu->scratch, 2);
     return my->dbus_message_append_args_valist(message, arg, VARARGS);
 }
@@ -452,48 +419,36 @@ EXPORT int my_dbus_message_append_args(x64emu_t* emu, void* message, int arg, ui
 EXPORT int my_dbus_message_set_data(x64emu_t* emu, void* message, int32_t slot, void* data, void* free_func)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     return my->dbus_message_set_data(message, slot, data, find_DBusFreeFunction_Fct(free_func));
 }
 
 EXPORT int my_dbus_pending_call_set_notify(x64emu_t* emu, void* pending, void* func, void* data, void* free_func)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     return my->dbus_pending_call_set_notify(pending, findDBusPendingCallNotifyFunctionFct(func), data, find_DBusFreeFunction_Fct(free_func));
 }
 
 EXPORT int my_dbus_pending_call_set_data(x64emu_t* emu, void* pending, int32_t slot, void* data, void* free_func)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     return my->dbus_pending_call_set_data(pending, slot, data, find_DBusFreeFunction_Fct(free_func));
 }
 
 EXPORT void my_dbus_watch_set_data(x64emu_t* emu, void* watch, void* data, void* free_func)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     my->dbus_watch_set_data(watch, data, find_DBusFreeFunction_Fct(free_func));
 }
 
 EXPORT void my_dbus_connection_set_dispatch_status_function(x64emu_t* emu, void* connection, void* dispatch, void* data, void* free_func)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     my->dbus_connection_set_dispatch_status_function(connection, findDBusDispatchStatusFunctionFct(dispatch), data, find_DBusFreeFunction_Fct(free_func));
 }
 
 EXPORT int my_dbus_connection_set_watch_functions(x64emu_t* emu, void* connection, void* add, void* remove, void* toggled, void* data, void* free_func)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     return my->dbus_connection_set_watch_functions(connection, findDBusAddWatchFunctionFct(add), findDBusRemoveWatchFunctionFct(remove), findDBusWatchToggledFunctionFct(toggled), data, find_DBusFreeFunction_Fct(free_func));
 }
 
@@ -510,8 +465,6 @@ typedef struct my_DBusObjectPathVTable_s
 EXPORT int my_dbus_connection_try_register_object_path(x64emu_t* emu, void* connection, void* path, my_DBusObjectPathVTable_t* vtable, void* data, void* error)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     my_DBusObjectPathVTable_t vt = {0};
     if(vtable) {
         vt.unregister_function = findDBusObjectPathUnregisterFunctionFct(vtable->unregister_function);
@@ -528,24 +481,18 @@ EXPORT int my_dbus_connection_try_register_object_path(x64emu_t* emu, void* conn
 EXPORT int my_dbus_connection_set_data(x64emu_t* emu, void* connection, int slot, void* data, void* free_func)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     return my->dbus_connection_set_data(connection, slot, data, find_DBusFreeFunction_Fct(free_func));
 }
 
 EXPORT void my_dbus_connection_set_wakeup_main_function(x64emu_t* emu, void* connection, void* wakeup, void* data, void* free_func)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     my->dbus_connection_set_wakeup_main_function(connection, find_DBusWakeupMainFunction_Fct(wakeup), data, find_DBusFreeFunction_Fct(free_func));
 }
 
 EXPORT int my_dbus_connection_try_register_fallback(x64emu_t* emu, void* connection, void* path, my_DBusObjectPathVTable_t* vtable, void* data, void* error)
 {
     (void)emu;
-    dbus_my_t *my = (dbus_my_t*)my_lib->priv.w.p2;
-
     my_DBusObjectPathVTable_t vt = {0};
     if(vtable) {
         vt.unregister_function = findDBusObjectPathUnregisterFunctionFct(vtable->unregister_function);
@@ -562,12 +509,9 @@ EXPORT int my_dbus_connection_try_register_fallback(x64emu_t* emu, void* connect
 
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getDBusMy(lib);    \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeDBusMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappeddbusglib1.c b/src/wrapped/wrappeddbusglib1.c
index 840a4469..b6680460 100755
--- a/src/wrapped/wrappeddbusglib1.c
+++ b/src/wrapped/wrappeddbusglib1.c
@@ -21,41 +21,9 @@
 const char* dbusglib1Name = "libdbus-glib-1.so.2";
 #define LIBNAME dbusglib1
 
-typedef void (*vFppp_t)(void*, void*, void*);
-typedef void (*vFpppp_t)(void*, void*, void*, void*);
-typedef void (*vFppppp_t)(void*, void*, void*, void*, void*);
-typedef void*(*pFpppppiV_t)(void*, void*, void*, void*, void*, int, ...);
-typedef void*(*pFpppppiiV_t)(void*, void*, void*, void*, void*, int, int, ...);
+#include "generated/wrappeddbusglib1types.h"
 
-#define SUPER() \
-    GO(dbus_g_type_collection_value_iterate, vFppp_t)   \
-    GO(dbus_g_type_map_value_iterate, vFppp_t)          \
-    GO(dbus_g_proxy_begin_call, pFpppppiV_t)            \
-    GO(dbus_g_proxy_begin_call_with_timeout, pFpppppiiV_t)  \
-    GO(dbus_g_proxy_connect_signal, vFppppp_t)          \
-    GO(dbus_g_proxy_disconnect_signal, vFpppp_t)
-
-typedef struct dbusglib1_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} dbusglib1_my_t;
-
-static void* getDBusGLib1My(library_t* lib)
-{
-    dbusglib1_my_t* my = (dbusglib1_my_t*)calloc(1, sizeof(dbusglib1_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-static void freeDBusGLib1My(void* lib)
-{
-    //dbusglib1_my_t *my = (dbusglib1_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
     GO(0)   \
@@ -203,25 +171,16 @@ static void* findDBusGTypeSpecializedMapIteratorFct(void* fct)
 
 EXPORT void my_dbus_g_type_collection_value_iterate(x64emu_t* emu, void* value, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(dbusglib1Name);
-    dbusglib1_my_t *my = (dbusglib1_my_t*)lib->priv.w.p2;
-
     my->dbus_g_type_collection_value_iterate(value, findDBusGTypeSpecializedCollectionIteratorFct(cb), data);
 }
 
 EXPORT void my_dbus_g_type_map_value_iterate(x64emu_t* emu, void* value, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(dbusglib1Name);
-    dbusglib1_my_t *my = (dbusglib1_my_t*)lib->priv.w.p2;
-
     my->dbus_g_type_map_value_iterate(value, findDBusGTypeSpecializedMapIteratorFct(cb), data);
 }
 
 EXPORT void* my_dbus_g_proxy_begin_call(x64emu_t* emu, void* proxy, void* method, void* notify, void* data, void* destroy, int first, int64_t* next)
 {
-    library_t * lib = GetLibInternal(dbusglib1Name);
-    dbusglib1_my_t *my = (dbusglib1_my_t*)lib->priv.w.p2;
-
     int narg = 0;
     if(first)
         while(next[narg]) ++narg;
@@ -238,9 +197,6 @@ EXPORT void* my_dbus_g_proxy_begin_call(x64emu_t* emu, void* proxy, void* method
 
 EXPORT void* my_dbus_g_proxy_begin_call_with_timeout(x64emu_t* emu, void* proxy, void* method, void* notify, void* data, void* destroy, int timeout, int first, int64_t* next)
 {
-    library_t * lib = GetLibInternal(dbusglib1Name);
-    dbusglib1_my_t *my = (dbusglib1_my_t*)lib->priv.w.p2;
-
     int narg = 0;
     if(first)
         while(next[narg]) ++narg;
@@ -257,17 +213,11 @@ EXPORT void* my_dbus_g_proxy_begin_call_with_timeout(x64emu_t* emu, void* proxy,
 
 EXPORT void my_dbus_g_proxy_connect_signal(x64emu_t* emu, void* proxy, void* name, void* handler, void* data, void* free_fnc)
 {
-    library_t * lib = GetLibInternal(dbusglib1Name);
-    dbusglib1_my_t *my = (dbusglib1_my_t*)lib->priv.w.p2;
-
     my->dbus_g_proxy_connect_signal(proxy, name, findGCallbackFct(handler), data, findGClosureNotifyFct(free_fnc));
 }
 
 EXPORT void my_dbus_g_proxy_disconnect_signal(x64emu_t* emu, void* proxy, void* name, void* handler, void* data)
 {
-    library_t * lib = GetLibInternal(dbusglib1Name);
-    dbusglib1_my_t *my = (dbusglib1_my_t*)lib->priv.w.p2;
-
     my->dbus_g_proxy_disconnect_signal(proxy, name, findGCallbackFct(handler), data);
 }
 
@@ -276,11 +226,10 @@ EXPORT void my_dbus_g_proxy_disconnect_signal(x64emu_t* emu, void* proxy, void*
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getDBusGLib1My(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeDBusGLib1My(lib->priv.w.p2);\
-    free(lib->priv.w.p2);
+    freeMy();
 
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedexpat.c b/src/wrapped/wrappedexpat.c
index 713482e9..58127004 100755
--- a/src/wrapped/wrappedexpat.c
+++ b/src/wrapped/wrappedexpat.c
@@ -20,31 +20,10 @@
 
 const char* expatName = "libexpat.so.1";
 #define LIBNAME expat
-static library_t* my_lib = NULL;
 
 #include "generated/wrappedexpattypes.h"
 
-typedef struct expat_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} expat_my_t;
-
-void* getExpatMy(library_t* lib)
-{
-    expat_my_t* my = (expat_my_t*)calloc(1, sizeof(expat_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeExpatMy(void* lib)
-{
-    //expat_my_t *my = (expat_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -123,23 +102,18 @@ static void* find_CharData_Fct(void* fct)
 
 EXPORT void my_XML_SetElementHandler(x64emu_t* emu, void* p, void* start, void* end)
 {
-    expat_my_t *my = (expat_my_t*)my_lib->priv.w.p2;
     my->XML_SetElementHandler(p, find_Start_Fct(start), find_End_Fct(end));
 }
 
 EXPORT void my_XML_SetCharacterDataHandler(x64emu_t* emu, void* p, void* h)
 {
-    expat_my_t *my = (expat_my_t*)my_lib->priv.w.p2;
     my->XML_SetCharacterDataHandler(p, find_CharData_Fct(h));
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getExpatMy(lib); \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeExpatMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedfaudio.c b/src/wrapped/wrappedfaudio.c
index 6668c130..9ca83cb0 100644
--- a/src/wrapped/wrappedfaudio.c
+++ b/src/wrapped/wrappedfaudio.c
@@ -20,31 +20,10 @@
 
 const char* faudioName = "libFAudio.so.0";
 #define LIBNAME faudio
-static library_t* my_lib = NULL;
 
 #include "generated/wrappedfaudiotypes.h"
 
-typedef struct faudio_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} faudio_my_t;
-
-void* getFAudioMy(library_t* lib)
-{
-    faudio_my_t* my = (faudio_my_t*)calloc(1, sizeof(faudio_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeFAudioMy(void* lib)
-{
-    //faudio_my_t *my = (faudio_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -420,69 +399,56 @@ static void wrapFAudioVoiceCallback(my_FAudioVoiceCallback_t* src, my_FAudioVoic
 }
 
 EXPORT uint32_t my_FAudioCreateVolumeMeterWithCustomAllocatorEXT(x64emu_t* emu, void* ppApo, uint32_t flags, void* customMalloc, void* customFree, void* customRealloc) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     return my->FAudioCreateVolumeMeterWithCustomAllocatorEXT(ppApo, flags, find_FAudioMalloc_Fct(customMalloc), find_FAudioFree_Fct(customFree), find_FAudioRealloc_Fct(customRealloc));
 }
 
 EXPORT uint32_t my_FAudioCreateReverbWithCustomAllocatorEXT(x64emu_t* emu, void* ppApo, uint32_t flags, void* customMalloc, void* customFree, void* customRealloc) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     return my->FAudioCreateReverbWithCustomAllocatorEXT(ppApo, flags, find_FAudioMalloc_Fct(customMalloc), find_FAudioFree_Fct(customFree), find_FAudioRealloc_Fct(customRealloc));
 }
 
 EXPORT uint32_t my_FAudioCreateReverb9WithCustomAllocatorEXT(x64emu_t* emu, void* ppApo, uint32_t flags, void* customMalloc, void* customFree, void* customRealloc) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     return my->FAudioCreateReverb9WithCustomAllocatorEXT(ppApo, flags, find_FAudioMalloc_Fct(customMalloc), find_FAudioFree_Fct(customFree), find_FAudioRealloc_Fct(customRealloc));
 }
 
 EXPORT uint32_t my_FAudio_RegisterForCallbacks(x64emu_t* emu, void* audio, my_FAudioEngineCallback_t* p) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     my_FAudioEngineCallback_t cb = {0};
     wrapFAudioEngineCallback(p, &cb);
     return my->FAudio_RegisterForCallbacks(audio, &cb);
 }
 EXPORT void my_FAudio_UnregisterForCallbacks(x64emu_t* emu, void* audio, my_FAudioEngineCallback_t* p) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     my_FAudioEngineCallback_t cb = {0};
     wrapFAudioEngineCallback(p, &cb);
     my->FAudio_UnregisterForCallbacks(audio, &cb);
 }
 
 EXPORT uint32_t my_FAudio_CreateSourceVoice(x64emu_t* emu, void* audio, void* voices, void* format, uint32_t flags, float ratio, my_FAudioVoiceCallback_t* p, void* send, void* effect) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     my_FAudioVoiceCallback_t cb = {0};
     wrapFAudioVoiceCallback(p, &cb);
     return my->FAudio_CreateSourceVoice(audio, voices, format, flags, ratio, &cb, send, effect);
 }
 
 EXPORT uint32_t my_FAudioCreateWithCustomAllocatorEXT(x64emu_t* emu, void* pp, uint32_t flags, uint32_t proc, void* customMalloc, void* customFree, void* customRealloc) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     return my->FAudioCreateWithCustomAllocatorEXT(pp, flags, proc, find_FAudioMalloc_Fct(customMalloc), find_FAudioFree_Fct(customFree), find_FAudioRealloc_Fct(customRealloc));
 }
 
 EXPORT uint32_t my_FAudioCOMConstructWithCustomAllocatorEXT(x64emu_t* emu, void* pp, uint8_t ver,void* customMalloc, void* customFree, void* customRealloc) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     return my->FAudioCOMConstructWithCustomAllocatorEXT(pp, ver, find_FAudioMalloc_Fct(customMalloc), find_FAudioFree_Fct(customFree), find_FAudioRealloc_Fct(customRealloc));
 }
 
 EXPORT void my_FAudio_SetEngineProcedureEXT(x64emu_t* emu, void* audio, void* p, void* user) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     my->FAudio_SetEngineProcedureEXT(audio, find_FAudioEngineProcedureEXT_Fct(p), user);
 }
 
 EXPORT uint32_t my_FAPOFX_CreateFXWithCustomAllocatorEXT(x64emu_t* emu, void* clsid, void* p, void* data, uint32_t size, void* customMalloc, void* customFree, void* customRealloc) {
-    faudio_my_t *my = (faudio_my_t*)my_lib->priv.w.p2;
     return my->FAPOFX_CreateFXWithCustomAllocatorEXT(clsid, p, data, size, find_FAudioMalloc_Fct(customMalloc), find_FAudioFree_Fct(customFree), find_FAudioRealloc_Fct(customRealloc));
 }
 
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getFAudioMy(lib); \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeFAudioMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedflac.c b/src/wrapped/wrappedflac.c
index e195f6d1..4bff742f 100755
--- a/src/wrapped/wrappedflac.c
+++ b/src/wrapped/wrappedflac.c
@@ -21,8 +21,6 @@
 const char* flacName = "libFLAC.so.8";
 #define LIBNAME flac
 
-static library_t *my_lib = NULL;
-
 typedef struct {
   size_t (*read_func)  (void *ptr, size_t size, size_t nmemb, void *handle);
   size_t (*write_func)  (void *ptr, size_t size, size_t nmemb, void *handle);
@@ -35,27 +33,11 @@ typedef struct {
 typedef int (*iFppC_t)(void*, void*, flac_callbacks);
 typedef int (*iFpppppppppp_t)(void*, void*, void*, void*, void*, void*, void*, void*, void*, void*);
 
-typedef struct flac_my_s {
-    // functions
-    iFppC_t         FLAC__metadata_chain_read_with_callbacks;
-    iFpppppppppp_t  FLAC__stream_decoder_init_stream;
-} flac_my_t;
-
-void* getFlacMy(library_t* lib)
-{
-    flac_my_t* my = (flac_my_t*)calloc(1, sizeof(flac_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    GO(FLAC__metadata_chain_read_with_callbacks, iFppC_t)
-    GO(FLAC__stream_decoder_init_stream, iFpppppppppp_t)
-    #undef GO
-    return my;
-}
+#define SUPER() \
+    GO(FLAC__metadata_chain_read_with_callbacks, iFppC_t)   \
+    GO(FLAC__stream_decoder_init_stream, iFpppppppppp_t)    \
 
-void freeFlacMy(void* lib)
-{
-    (void)lib;
-    //flac_my_t *my = (flac_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)           \
@@ -338,7 +320,6 @@ static void* findErrorFct(void* fct)
 EXPORT int my_FLAC__metadata_chain_read_with_callbacks(x64emu_t* emu, void* chain, void* handle, 
     void* read_fnc, void* write_fnc, void* seek_fnc, void* tell_fnc, void* eof_fnc, void* close_fnc)
 {
-    flac_my_t* my = (flac_my_t*)my_lib->priv.w.p2;
     flac_callbacks cbs = {0};
     cbs.read_func = findread_writeFct(read_fnc);
     cbs.write_func = findread_writeFct(write_fnc);
@@ -354,8 +335,6 @@ EXPORT int my_FLAC__stream_decoder_init_stream(x64emu_t* emu, void* decoder,
     void* read_fnc, void* seek_fnc, void* tell_fnc, void* length_fnc, void* eof_fnc, 
     void* write_fnc, void* metadata_fnc, void* error_fnc, void* data)
 {
-    flac_my_t* my = (flac_my_t*)my_lib->priv.w.p2;
-
     int ret =  my->FLAC__stream_decoder_init_stream(decoder, 
         findReadFct(read_fnc), findSeekFct(seek_fnc), findTellFct(tell_fnc),
         findLengthFct(length_fnc), findEofFct(eof_fnc), findWriteFct(write_fnc),
@@ -365,13 +344,10 @@ EXPORT int my_FLAC__stream_decoder_init_stream(x64emu_t* emu, void* decoder,
 
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getFlacMy(lib);    \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeFlacMy(lib->priv.w.p2);     \
-    free(lib->priv.w.p2);           \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedfreetype.c b/src/wrapped/wrappedfreetype.c
index 9936bed8..d66049b0 100755
--- a/src/wrapped/wrappedfreetype.c
+++ b/src/wrapped/wrappedfreetype.c
@@ -116,28 +116,7 @@ typedef int (*iFpuuLppp_t)  (void*, uint32_t, uint32_t, uintptr_t, void*, void*,
     GO(FT_Open_Face, iFpplp_t)      \
     GO(FTC_Manager_New, iFpuuLppp_t)
 
-typedef struct freetype_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} freetype_my_t;
-
-void* getFreeTypeMy(library_t* lib)
-{
-    freetype_my_t* my = (freetype_my_t*)calloc(1, sizeof(freetype_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeFreeTypeMy(void* lib)
-{
-    (void)lib;
-    //freetype_my_t *my = (freetype_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 // utility functions
 #define SUPER() \
@@ -215,9 +194,6 @@ static void my_FT_Stream_CloseFunc(FT_StreamRec_t* stream)
 EXPORT int my_FT_Open_Face(x64emu_t* emu, void* library, FT_Open_Args_t* args, long face_index, void* aface)
 {
     (void)emu;
-    library_t* lib = GetLibInternal(freetypeName);
-    freetype_my_t* my = (freetype_my_t*)lib->priv.w.p2;
-
     int wrapstream = (args->flags&0x02)?1:0;
     if(wrapstream) {
         my_iofunc = (uintptr_t)args->stream->read;
@@ -238,17 +214,13 @@ EXPORT int my_FT_Open_Face(x64emu_t* emu, void* library, FT_Open_Args_t* args, l
 EXPORT int my_FTC_Manager_New(x64emu_t* emu, void* l, uint32_t max_faces, uint32_t max_sizes, uintptr_t max_bytes, void* req, void* data, void* aman)
 {
     (void)emu;
-    library_t* lib = GetLibInternal(freetypeName);
-    freetype_my_t* my = (freetype_my_t*)lib->priv.w.p2;
-
     return my->FTC_Manager_New(l, max_faces, max_sizes, max_bytes, find_FTC_Face_Requester_Fct(req), data, aman);
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getFreeTypeMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeFreeTypeMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedgdkpixbuf2.c b/src/wrapped/wrappedgdkpixbuf2.c
index fec5adcd..1f82399d 100755
--- a/src/wrapped/wrappedgdkpixbuf2.c
+++ b/src/wrapped/wrappedgdkpixbuf2.c
@@ -20,32 +20,9 @@
 const char* gdkpixbuf2Name = "libgdk_pixbuf-2.0.so.0";
 #define LIBNAME gdkpixbuf2
 
-typedef void* (*pFpiiiiiipp_t)(void*, int32_t, int32_t, int32_t, int32_t, int32_t, int32_t, void*, void*);
+#include "generated/wrappedgdkpixbuf2types.h"
 
-#define SUPER() \
-    GO(gdk_pixbuf_new_from_data, pFpiiiiiipp_t)
-
-typedef struct gdkpixbuf2_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} gdkpixbuf2_my_t;
-
-void* getGdkpixbuf2My(library_t* lib)
-{
-    gdkpixbuf2_my_t* my = (gdkpixbuf2_my_t*)calloc(1, sizeof(gdkpixbuf2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeGdkpixbuf2My(void* lib)
-{
-    //gdkpixbuf2_my_t *my = (gdkpixbuf2_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -80,9 +57,6 @@ static void* finddestroy_pixbufFct(void* fct)
 
 EXPORT void* my_gdk_pixbuf_new_from_data(x64emu_t* emu, void* data, int32_t colorspace, int32_t has_alpha, int32_t bpp, int32_t w, int32_t h, int32_t stride, void* destroy_func, void* destroy_data)
 {
-    library_t * lib = GetLibInternal(gdkpixbuf2Name);
-    gdkpixbuf2_my_t *my = (gdkpixbuf2_my_t*)lib->priv.w.p2;
-
     return my->gdk_pixbuf_new_from_data(data, colorspace, has_alpha, bpp, w, h, stride, finddestroy_pixbufFct(destroy_func), destroy_data);
 }
 
@@ -92,10 +66,9 @@ EXPORT void* my_gdk_pixbuf_new_from_data(x64emu_t* emu, void* data, int32_t colo
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getGdkpixbuf2My(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeGdkpixbuf2My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedgdkx112.c b/src/wrapped/wrappedgdkx112.c
index abb87ca3..d1caef01 100755
--- a/src/wrapped/wrappedgdkx112.c
+++ b/src/wrapped/wrappedgdkx112.c
@@ -25,40 +25,9 @@ static char* libname = NULL;
 
 char* getGDKX11LibName() {return libname;}
 
-typedef int     (*iFpp_t)       (void*, void*);
-typedef void    (*vFpp_t)       (void*, void*);
-typedef void    (*vFppp_t)      (void*, void*, void*);
-typedef int     (*iFiippp_t)    (int, int, void*, void*, void*);
+#include "generated/wrappedgdkx112types.h"
 
-#define SUPER() \
-    GO(gdk_event_handler_set, vFppp_t)          \
-    GO(gdk_input_add_full, iFiippp_t)           \
-    GO(gdk_init, vFpp_t)                        \
-    GO(gdk_init_check, iFpp_t)                  \
-    GO(gdk_window_add_filter, vFppp_t)          \
-    GO(gdk_window_remove_filter, vFppp_t)
-
-typedef struct gdkx112_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} gdkx112_my_t;
-
-void* getGdkX112My(library_t* lib)
-{
-    gdkx112_my_t* my = (gdkx112_my_t*)calloc(1, sizeof(gdkx112_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeGdkX112My(void* lib)
-{
-    //gdkx112_my_t *my = (gdkx112_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -97,9 +66,6 @@ static void my_event_handler(void* event, my_signal_t* sig)
 
 EXPORT void my_gdk_event_handler_set(x64emu_t* emu, void* func, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gdkx112_my_t *my = (gdkx112_my_t*)lib->priv.w.p2;
-
     if(!func)
         return my->gdk_event_handler_set(func, data, notify);
 
@@ -115,9 +81,6 @@ static void my_input_function(my_signal_t* sig, int source, int condition)
 
 EXPORT int my_gdk_input_add(x64emu_t* emu, int source, int condition, void* f, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gdkx112_my_t *my = (gdkx112_my_t*)lib->priv.w.p2;
-
     if(!f)
         return my->gdk_input_add_full(source, condition, f, data, NULL);
 
@@ -127,9 +90,6 @@ EXPORT int my_gdk_input_add(x64emu_t* emu, int source, int condition, void* f, v
 
 EXPORT int my_gdk_input_add_full(x64emu_t* emu, int source, int condition, void* f, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gdkx112_my_t *my = (gdkx112_my_t*)lib->priv.w.p2;
-
     if(!f)
         return my->gdk_input_add_full(source, condition, f, data, notify);
     
@@ -139,18 +99,12 @@ EXPORT int my_gdk_input_add_full(x64emu_t* emu, int source, int condition, void*
 
 EXPORT void my_gdk_init(x64emu_t* emu, void* argc, void* argv)
 {
-    library_t * lib = GetLibInternal(libname);
-    gdkx112_my_t *my = (gdkx112_my_t*)lib->priv.w.p2;
-
     my->gdk_init(argc, argv);
     my_checkGlobalGdkDisplay();
 }
 
 EXPORT int my_gdk_init_check(x64emu_t* emu, void* argc, void* argv)
 {
-    library_t * lib = GetLibInternal(libname);
-    gdkx112_my_t *my = (gdkx112_my_t*)lib->priv.w.p2;
-
     int ret = my->gdk_init_check(argc, argv);
     my_checkGlobalGdkDisplay();
     return ret;
@@ -158,17 +112,11 @@ EXPORT int my_gdk_init_check(x64emu_t* emu, void* argc, void* argv)
 
 EXPORT void my_gdk_window_add_filter(x64emu_t* emu, void* window, void* f, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gdkx112_my_t *my = (gdkx112_my_t*)lib->priv.w.p2;
-
     my->gdk_window_add_filter(window, findFilterFct(f), data);
 }
 
 EXPORT void my_gdk_window_remove_filter(x64emu_t* emu, void* window, void* f, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gdkx112_my_t *my = (gdkx112_my_t*)lib->priv.w.p2;
-
     my->gdk_window_remove_filter(window, findFilterFct(f), data);
 }
 
@@ -176,18 +124,13 @@ EXPORT void my_gdk_window_remove_filter(x64emu_t* emu, void* window, void* f, vo
     if(box64_nogtk) \
         return -1;
 
-#define CUSTOM_INIT \
-    libname = lib->name;                        \
-    lib->priv.w.p2 = getGdkX112My(lib);         \
-    lib->priv.w.needed = 3;                     \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libgobject-2.0.so.0"); \
-    lib->priv.w.neededlibs[1] = strdup("libgio-2.0.so.0");  \
-    lib->priv.w.neededlibs[2] = strdup("libgdk_pixbuf-2.0.so.0");
+#define CUSTOM_INIT         \
+    libname = lib->name;    \
+    getMy(lib);             \
+    setNeededLibs(&lib->priv.w, 3, "libgobject-2.0.so.0", "libgio-2.0.so.0", "libgdk_pixbuf-2.0.so.0");
 
 #define CUSTOM_FINI \
-    freeGdkX112My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy(); \
 
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedgio2.c b/src/wrapped/wrappedgio2.c
index a9c89080..5be5f7af 100755
--- a/src/wrapped/wrappedgio2.c
+++ b/src/wrapped/wrappedgio2.c
@@ -29,29 +29,7 @@ static char* libname = NULL;
 
 #include "wrappedgio2types.h"
 
-
-typedef struct gio2_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} gio2_my_t;
-
-void* getGio2My(library_t* lib)
-{
-    gio2_my_t* my = (gio2_my_t*)calloc(1, sizeof(gio2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeGio2My(void* lib)
-{
-    //gio2_my_t *my = (gio2_my_t *)lib;
-}
-
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -391,57 +369,36 @@ static my_GDBusInterfaceVTable_t* findFreeGDBusInterfaceVTable(my_GDBusInterface
 
 EXPORT void my_g_dbus_proxy_new(x64emu_t* emu, void* connection, int flags, void* info, void* name, void* path, void* interface, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_proxy_new(connection, flags, info, name, path, interface, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_dbus_proxy_new_for_bus(x64emu_t* emu, int bus_type, int flags, void* info, void* name, void* path, void* interface, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_proxy_new_for_bus(bus_type, flags, info, name, path, interface, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_dbus_proxy_call(x64emu_t* emu, void* proxy, void* name, void* param, int flags, int timeout, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_proxy_call(proxy, name, param, flags, timeout, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_dbus_proxy_call_with_unix_fd_list(x64emu_t* emu, void* proxy, void* name, void* param, int flags, int timeout, void* fd_list, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_proxy_call_with_unix_fd_list(proxy, name, param, flags, timeout, fd_list, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void* my_g_dbus_object_manager_client_new_for_bus_sync(x64emu_t* emu, size_t bus, int flags, void* name, void* path, void* cb, void* data, void* destroy, void* cancellable, void* error)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_dbus_object_manager_client_new_for_bus_sync(bus, flags, name, path, findGDBusProxyTypeFuncFct(cb), data, findGDestroyNotifyFct(destroy), cancellable, error);
 }
 
 EXPORT void* my_g_simple_async_result_new(x64emu_t* emu, void* source, void* cb, void* data, void* tag)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_simple_async_result_new(source, findGAsyncReadyCallbackFct(cb), data, tag);
 }
 
 EXPORT void* my_g_simple_async_result_new_error(x64emu_t* emu, void* source, void* cb, void* data, uint32_t domain, int code, void* fmt, va_list b)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     char* tmp;
     int dummy = vasprintf(&tmp, fmt, b);
     (void)dummy;
@@ -452,41 +409,26 @@ EXPORT void* my_g_simple_async_result_new_error(x64emu_t* emu, void* source, voi
 
 EXPORT void* my_g_simple_async_result_new_from_error(x64emu_t* emu, void* source, void* cb, void* data, void* error)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_simple_async_result_new_from_error(source, findGAsyncReadyCallbackFct(cb), data, error);
 }
 
 EXPORT void* my_g_simple_async_result_new_take_error(x64emu_t* emu, void* source, void* cb, void* data, void* error)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_simple_async_result_new_take_error(source, findGAsyncReadyCallbackFct(cb), data, error);
 }
 
 EXPORT void my_g_simple_async_result_set_op_res_gpointer(x64emu_t* emu, void* simple, void* op, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_simple_async_result_set_op_res_gpointer(simple, op, findGDestroyNotifyFct(notify));
 }
 
 EXPORT void my_g_simple_async_result_run_in_thread(x64emu_t* emu, void* simple, void* fnc, int priority, void* cancellable)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_simple_async_result_run_in_thread(simple, findGSimpleAsyncThreadFuncFct(fnc), priority, cancellable);
 }
 
 EXPORT void my_g_simple_async_report_error_in_idle(x64emu_t* emu, void* object, void* cb, void* data, uint32_t domain, int code, void* fmt, va_list b)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     char* tmp;
     int dummy = vasprintf(&tmp, fmt, b);
     (void)dummy;
@@ -496,41 +438,26 @@ EXPORT void my_g_simple_async_report_error_in_idle(x64emu_t* emu, void* object,
 
 EXPORT void my_g_simple_async_report_gerror_in_idle(x64emu_t* emu, void* object, void* cb, void* data, void* error)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_simple_async_report_gerror_in_idle(object, findGAsyncReadyCallbackFct(cb), data, error);
 }
 
 EXPORT void my_g_simple_async_report_take_gerror_in_idle(x64emu_t* emu, void* object, void* cb, void* data, void* error)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_simple_async_report_take_gerror_in_idle(object, findGAsyncReadyCallbackFct(cb), data, error);
 }
 
 EXPORT unsigned long my_g_cancellable_connect(x64emu_t* emu, void* cancellable, void* cb, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_cancellable_connect(cancellable, findGCallbackFct(cb), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT void my_g_async_initable_init_async(x64emu_t* emu, void* initable, int priority, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_async_initable_init_async(initable, priority, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_async_initable_new_valist_async(x64emu_t* emu, size_t type, void* first, x64_va_list_t var_args, int priority, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(var_args);
     #else
@@ -541,138 +468,87 @@ EXPORT void my_g_async_initable_new_valist_async(x64emu_t* emu, size_t type, voi
 
 EXPORT void my_g_async_initable_new_async(x64emu_t* emu, size_t type, int priority, void* cancellable, void* cb, void* data, void* first, uintptr_t* V)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     CREATE_VALIST_FROM_VAARG(V, emu->scratch, 6);
     my->g_async_initable_new_valist_async(type, first, VARARGS, priority, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_async_initable_newv_async(x64emu_t* emu, size_t type, uint32_t n, void* params, int priority, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_async_initable_newv_async(type, n, params, priority, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_bus_get(x64emu_t* emu, size_t type, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_bus_get(type, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_dbus_connection_new(x64emu_t* emu, void* stream, void* guid, int flags, void* observer, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_connection_new(stream, guid, flags, observer, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_dbus_connection_new_for_address(x64emu_t* emu, void* address, int flags, void* observer, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_connection_new_for_address(address, flags, observer, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_dbus_connection_close(x64emu_t* emu, void* connection, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_connection_close(connection, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_dbus_connection_flush(x64emu_t* emu, void* connection, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_connection_flush(connection, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT void my_g_dbus_connection_call(x64emu_t* emu, void* connection, void* bus, void* object, void* interface, void* method, void* param, void* reply, int flags, int timeout, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_connection_call(connection, bus, object, interface, method, param, reply, flags, timeout, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT uint32_t my_g_dbus_connection_signal_subscribe(x64emu_t* emu, void* connection, void* sender, void* interface, void* member, void* object, void* arg0, int flags, void* cb, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_dbus_connection_signal_subscribe(connection, sender, interface, member, object, arg0, flags, findGDBusSignalCallbackFct(cb), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT void my_g_dbus_connection_send_message_with_reply(x64emu_t* emu, void* connection, void* message, int flags, int timeout, void* serial, void* cancellable, void* cb, void* data)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     my->g_dbus_connection_send_message_with_reply(connection, message, flags, timeout, serial, cancellable, findGAsyncReadyCallbackFct(cb), data);
 }
 
 EXPORT uint32_t my_g_dbus_connection_add_filter(x64emu_t* emu, void* connection, void* cb, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_dbus_connection_add_filter(connection, findGDBusMessageFilterFunctionFct(cb), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT uint32_t my_g_dbus_connection_register_object(x64emu_t* emu, void* connection, void* object, void* info, my_GDBusInterfaceVTable_t* vtable, void* data, void* notify, void* error)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_dbus_connection_register_object(connection, object, info, findFreeGDBusInterfaceVTable(vtable), data, findGDestroyNotifyFct(notify), error);
 }
 
 EXPORT uint32_t my_g_bus_watch_name(x64emu_t* emu, size_t type, void* name, int flags, void* appeared, void* vanished, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_bus_watch_name(type, name, flags, findGBusNameAppearedCallbackFct(appeared), findGBusNameVanishedCallbackFct(vanished), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT uint32_t my_g_bus_watch_name_on_connection(x64emu_t* emu, void* connection, void* name, int flags, void* appeared, void* vanished, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_bus_watch_name_on_connection(connection, name, flags, findGBusNameAppearedCallbackFct(appeared), findGBusNameVanishedCallbackFct(vanished), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT uint32_t my_g_bus_own_name(x64emu_t* emu, size_t type, void* name, int flags, void* bus_acquired, void* name_acquired, void* name_lost, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_bus_own_name(type, name, flags, findGBusAcquiredCallbackFct(bus_acquired), findGBusNameAcquiredCallbackFct(name_acquired), findGBusNameLostCallbackFct(name_lost), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT uint32_t my_g_bus_own_name_on_connection(x64emu_t* emu, void* connection, void* name, int flags, void* name_acquired, void* name_lost, void* data, void* notify)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     return my->g_bus_own_name_on_connection(connection, name, flags, findGBusNameAcquiredCallbackFct(name_acquired), findGBusNameLostCallbackFct(name_lost), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT void my_g_simple_async_result_set_error_va(x64emu_t* emu, void* simple, void* domain, int code, void* fmt, x64_va_list_t V)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -683,9 +559,6 @@ EXPORT void my_g_simple_async_result_set_error_va(x64emu_t* emu, void* simple, v
 
 EXPORT void my_g_simple_async_result_set_error(x64emu_t* emu, void* simple, void* domain, int code, void* fmt, uintptr_t* b)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 4);
     PREPARE_VALIST;
     my->g_simple_async_result_set_error_va(simple, domain, code, fmt, VARARGS);
@@ -693,9 +566,6 @@ EXPORT void my_g_simple_async_result_set_error(x64emu_t* emu, void* simple, void
 
 EXPORT void* my_g_initable_new(x64emu_t* emu, void* type, void* cancel, void* err, void* first, uintptr_t* b)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     myStackAlign(emu, first, b, emu->scratch, R_EAX, 4);
     PREPARE_VALIST;
     return my->g_initable_new_valist(type, first, VARARGS, cancel, err);
@@ -703,9 +573,6 @@ EXPORT void* my_g_initable_new(x64emu_t* emu, void* type, void* cancel, void* er
 
 EXPORT void* my_g_initable_new_valist(x64emu_t* emu, void* type, void* first, x64_va_list_t V, void* cancel, void* err)
 {
-    library_t * lib = GetLibInternal(libname);
-    gio2_my_t *my = (gio2_my_t*)lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -720,14 +587,10 @@ EXPORT void* my_g_initable_new_valist(x64emu_t* emu, void* type, void* first, x6
         return -1;
 
 #define CUSTOM_INIT \
-    libname = lib->name;                \
-    lib->priv.w.p2 = getGio2My(lib);   \
-    lib->priv.w.needed = 1;             \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libgmodule-2.0.so.0");
+    getMy(lib);                         \
+    setNeededLibs(&lib->priv.w, 1, "libgmodule-2.0.so.0");
 
 #define CUSTOM_FINI \
-    freeGio2My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedglib2.c b/src/wrapped/wrappedglib2.c
index cbaf7cad..48742b67 100755
--- a/src/wrapped/wrappedglib2.c
+++ b/src/wrapped/wrappedglib2.c
@@ -22,9 +22,6 @@
 
 const char* glib2Name = "libglib-2.0.so.0";
 #define LIBNAME glib2
-static library_t* my_lib = NULL;
-
-static char* libname = NULL;
 
 typedef void  (*vFppip_t)(void*, void*, int, void*);
 
@@ -36,30 +33,9 @@ typedef void  (*vFppip_t)(void*, void*, int, void*);
 
 #include "wrappedglib2types.h"
 
-typedef struct glib2_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} glib2_my_t;
-
-void* getGlib2My(library_t* lib)
-{
-    glib2_my_t* my = (glib2_my_t*)calloc(1, sizeof(glib2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeGlib2My(void* lib)
-{
-    //glib2_my_t *my = (glib2_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 EXPORT void* my_g_markup_vprintf_escaped(x64emu_t *emu, void* fmt, void* b) {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     // need to align on arm
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
@@ -68,7 +44,6 @@ EXPORT void* my_g_markup_vprintf_escaped(x64emu_t *emu, void* fmt, void* b) {
 
 EXPORT void* my_g_build_filename(x64emu_t* emu, void* first, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     int n = 0;
     while (getVArgs(emu, 1, b, n++));
     void* array[n+1];   // +1 for 1st (NULL terminal already included)
@@ -85,8 +60,6 @@ static int my_timeout_cb(my_signal_t* sig)
 }
 EXPORT uint32_t my_g_timeout_add(x64emu_t* emu, uint32_t interval, void* func, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my_signal_t *sig = new_mysignal(func, data, NULL);
     return my->g_timeout_add_full(0, interval, my_timeout_cb, sig, my_signal_delete);
 }
@@ -695,12 +668,10 @@ static void* reverseGOptionArgFct(void* fct)
 
 EXPORT void my_g_list_free_full(x64emu_t* emu, void* list, void* free_func)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     my->g_list_free_full(list, findFreeFct(free_func));
 }
 
 EXPORT void* my_g_markup_printf_escaped(x64emu_t *emu, void* fmt, void* b) {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     // need to align on arm
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
@@ -710,21 +681,18 @@ EXPORT void* my_g_markup_printf_escaped(x64emu_t *emu, void* fmt, void* b) {
 
 EXPORT void my_g_datalist_id_set_data_full(x64emu_t* emu, void* datalist, uintptr_t key, void* data, void* freecb)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     void* fc = findFreeFct(freecb);
     my->g_datalist_id_set_data_full(datalist, key, data, fc);
 }
 
 EXPORT void* my_g_datalist_id_dup_data(x64emu_t* emu, void* datalist, uintptr_t key, void* dupcb, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     void* cc = findDuplicateFct(dupcb);
     return my->g_datalist_id_dup_data(datalist, key, cc, data);
 }
 
 EXPORT int my_g_datalist_id_replace_data(x64emu_t* emu, void* datalist, uintptr_t key, void* oldval, void* newval, void* oldfree, void* newfree)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     void* oldfc = findFreeFct(oldfree);
     void* newfc = findFreeFct(newfree);
     return my->g_datalist_id_replace_data(datalist, key, oldval, newval, oldfc, newfc);
@@ -732,14 +700,12 @@ EXPORT int my_g_datalist_id_replace_data(x64emu_t* emu, void* datalist, uintptr_
 
 EXPORT void* my_g_variant_new_from_data(x64emu_t* emu, void* type, void* data, size_t size, int trusted, void* freecb, void* datacb)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     void* fc = findFreeFct(freecb);
     return my->g_variant_new_from_data(type, data, size, trusted, fc, datacb);
 }
 
 EXPORT void* my_g_variant_new_parsed_va(x64emu_t* emu, void* fmt, x64_va_list_t b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -750,14 +716,12 @@ EXPORT void* my_g_variant_new_parsed_va(x64emu_t* emu, void* fmt, x64_va_list_t
 
 EXPORT void my_g_variant_get(x64emu_t* emu, void* value, void* fmt, uint64_t* V)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     CREATE_VALIST_FROM_VAARG(V, emu->scratch, 2);
     my->g_variant_get_va(value, fmt, NULL, &VARARGS);
 }
 
 EXPORT void* my_g_strdup_vprintf(x64emu_t* emu, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->g_strdup_vprintf(fmt, VARARGS);
@@ -765,7 +729,6 @@ EXPORT void* my_g_strdup_vprintf(x64emu_t* emu, void* fmt, void* b)
 
 EXPORT int my_g_vprintf(x64emu_t* emu, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->g_vprintf(fmt, VARARGS);
@@ -773,7 +736,6 @@ EXPORT int my_g_vprintf(x64emu_t* emu, void* fmt, void* b)
 
 EXPORT int my_g_vfprintf(x64emu_t* emu, void* F, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
     return my->g_vfprintf(F, fmt, VARARGS);
@@ -781,7 +743,6 @@ EXPORT int my_g_vfprintf(x64emu_t* emu, void* F, void* fmt, void* b)
 
 EXPORT int my_g_vsprintf(x64emu_t* emu, void* s, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
     return my->g_vsprintf(s, fmt, VARARGS);
@@ -789,7 +750,6 @@ EXPORT int my_g_vsprintf(x64emu_t* emu, void* s, void* fmt, void* b)
 
 EXPORT int my_g_vsnprintf(x64emu_t* emu, void* s, unsigned long n, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
     return my->g_vsnprintf(s, n, fmt, VARARGS);
@@ -797,7 +757,6 @@ EXPORT int my_g_vsnprintf(x64emu_t* emu, void* s, unsigned long n, void* fmt, vo
 
 EXPORT int my_g_vasprintf(x64emu_t* emu, void* s, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
     return my->g_vasprintf(s, fmt, VARARGS);
@@ -805,7 +764,6 @@ EXPORT int my_g_vasprintf(x64emu_t* emu, void* s, void* fmt, void* b)
 
 EXPORT uint32_t my_g_printf_string_upper_bound(x64emu_t* emu, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->g_printf_string_upper_bound(fmt, VARARGS);
@@ -813,8 +771,6 @@ EXPORT uint32_t my_g_printf_string_upper_bound(x64emu_t* emu, void* fmt, void* b
 
 EXPORT void my_g_print(x64emu_t* emu, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
@@ -826,8 +782,6 @@ EXPORT void my_g_print(x64emu_t* emu, void* fmt, void* b)
 
 EXPORT void my_g_printerr(x64emu_t* emu, void* fmt, void* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
@@ -839,14 +793,11 @@ EXPORT void my_g_printerr(x64emu_t* emu, void* fmt, void* b)
 
 EXPORT void* my_g_source_new(x64emu_t* emu, my_GSourceFuncs_t* source_funcs, size_t struct_size)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_source_new(findFreeGSourceFuncs(source_funcs), struct_size);
 }
 
 EXPORT void my_g_source_set_funcs(x64emu_t* emu, void* source, my_GSourceFuncs_t* source_funcs)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
 
     my->g_source_set_funcs(source, findFreeGSourceFuncs(source_funcs));
 }
@@ -854,14 +805,11 @@ EXPORT void my_g_source_set_funcs(x64emu_t* emu, void* source, my_GSourceFuncs_t
 
 EXPORT int my_g_source_remove_by_funcs_user_data(x64emu_t* emu, my_GSourceFuncs_t* source_funcs, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_source_remove_by_funcs_user_data(findFreeGSourceFuncs(source_funcs), data);
 }
 
 EXPORT void* my_g_main_context_get_poll_func(x64emu_t* emu, void* context)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
 
     void* ret = my->g_main_context_get_poll_func(context);
     if(!ret) return ret;
@@ -873,15 +821,11 @@ EXPORT void* my_g_main_context_get_poll_func(x64emu_t* emu, void* context)
     
 EXPORT void my_g_main_context_set_poll_func(x64emu_t* emu, void* context, void* func)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_main_context_set_poll_func(context, findPollFct(func));
 }
 
 EXPORT uint32_t my_g_idle_add_full(x64emu_t* emu, int priority, void* f, void* data, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     if(!f)
         return my->g_idle_add_full(priority, f, data, notify);
 
@@ -892,231 +836,169 @@ EXPORT uint32_t my_g_idle_add_full(x64emu_t* emu, int priority, void* f, void* d
 
 EXPORT void* my_g_hash_table_new(x64emu_t* emu, void* hash, void* equal)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_hash_table_new(findHashFct(hash), findEqualFct(equal));
 }
 
 EXPORT void* my_g_hash_table_new_full(x64emu_t* emu, void* hash, void* equal, void* destroy_key, void* destroy_val)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_hash_table_new_full(findHashFct(hash), findEqualFct(equal), findDestroyFct(destroy_key), findDestroyFct(destroy_val));
 }
 
 EXPORT void my_g_hash_table_foreach(x64emu_t* emu, void* table, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_hash_table_foreach(table, findGHFuncFct(f), data);
 }
 
 EXPORT uint32_t my_g_hash_table_foreach_remove(x64emu_t* emu, void* table, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     
     return my->g_hash_table_foreach_remove(table, findGHRFuncFct(f), data);
 }
 EXPORT uint32_t my_g_hash_table_foreach_steal(x64emu_t* emu, void* table, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     
     return my->g_hash_table_foreach_steal(table, findGHRFuncFct(f), data);
 }
 EXPORT void* my_g_hash_table_find(x64emu_t* emu, void* table, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     
     return my->g_hash_table_find(table, findGHRFuncFct(f), data);
 }
 
 EXPORT int my_g_spawn_async_with_pipes(x64emu_t* emu, void* dir, void* argv, void* envp, int flags, void* f, void* data, void* child, void* input, void* output, void* err, void* error)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_spawn_async_with_pipes(dir, argv, envp, flags, findSpawnChildSetupFct(f), data, child, input, output, err, error);
 }
 
 EXPORT int my_g_spawn_async(x64emu_t* emu, void* dir, void* argv, void* envp, int flags, void* f, void* data, void* child, void* error)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_spawn_async(dir, argv, envp, flags, findSpawnChildSetupFct(f), data, child, error);
 }
 
 EXPORT int my_g_spawn_sync(x64emu_t* emu, void* dir, void* argv, void* envp, int flags, void* f, void* data, void* input, void* output, void* status, void* error)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_spawn_sync(dir, argv, envp, flags, findSpawnChildSetupFct(f), data, input, output, status, error);
 }
 
 EXPORT uint32_t my_g_child_watch_add(x64emu_t* emu, int pid, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_child_watch_add(pid, findGChildWatchFuncFct(f), data);
 }
 
 EXPORT uint32_t my_g_child_watch_add_full(x64emu_t* emu, int priority, int pid, void* f, void* data, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_idle_add_full(priority, findGChildWatchFuncFct(f), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT void* my_g_private_new(x64emu_t* emu, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_private_new(findFreeFct(notify));
 }
 
 EXPORT void my_g_static_private_set(x64emu_t* emu, void* private, void* data, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_static_private_set(private, data, findFreeFct(notify));
 }
 
 EXPORT void* my_g_ptr_array_new_with_free_func(x64emu_t* emu, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_ptr_array_new_with_free_func(findFreeFct(notify));
 }
 
 EXPORT void* my_g_ptr_array_new_full(x64emu_t* emu, uint32_t size, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_ptr_array_new_full(size, findFreeFct(notify));
 }
 
 EXPORT void my_g_ptr_array_set_free_func(x64emu_t* emu, void* array, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_ptr_array_set_free_func(array, findFreeFct(notify));
 }
 
 EXPORT void my_g_ptr_array_sort(x64emu_t* emu, void* array, void* comp)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_ptr_array_sort(array, findGCompareFuncFct(comp));
 }
 
 EXPORT void my_g_ptr_array_sort_with_data(x64emu_t* emu, void* array, void* comp, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_ptr_array_sort_with_data(array, findGCompareDataFuncFct(comp), data);
 }
 
 EXPORT void my_g_qsort_with_data(x64emu_t* emu, void* pbase, int total, unsigned long size, void* comp, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_qsort_with_data(pbase, total, size, findGCompareDataFuncFct(comp), data);
 }
 
 EXPORT void my_g_ptr_array_foreach(x64emu_t* emu, void* array, void* func, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_ptr_array_foreach(array, findGFuncFct(func), data);
 }
 
 EXPORT void* my_g_thread_create(x64emu_t* emu, void* func, void* data, int joinable, void* error)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     void* et = NULL;
     return my->g_thread_create(my_prepare_thread(emu, func, data, 0, &et), et, joinable, error);
 }
 
 EXPORT void* my_g_thread_create_full(x64emu_t* emu, void* func, void* data, unsigned long stack, int joinable, int bound, int priority, void* error)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     void* et = NULL;
     return my->g_thread_create_full(my_prepare_thread(emu, func, data, stack, &et), et, stack, joinable, bound, priority, error);
 }
 
 EXPORT void my_g_thread_foreach(x64emu_t* emu, void* func, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_thread_foreach(findGFuncFct(func), data);
 }
 
 EXPORT void my_g_array_sort(x64emu_t* emu, void* array, void* comp)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_array_sort(array, findGCompareFuncFct(comp));
 }
 
 EXPORT void my_g_array_sort_with_data(x64emu_t* emu, void* array, void* comp, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_array_sort_with_data(array, findGCompareDataFuncFct(comp), data);
 }
 
 EXPORT void my_g_array_set_clear_func(x64emu_t* emu, void* array, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_array_set_clear_func(array, findFreeFct(notify));
 }
 
 EXPORT void my_g_source_set_callback(x64emu_t* emu, void* source, void* func, void* data, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_source_set_callback(source, findGSourceFuncFct(func), data, findFreeFct(notify));
 }
 
 EXPORT void* my_g_slist_insert_sorted(x64emu_t* emu, void* list, void* d, void* comp)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
 
     return my->g_slist_insert_sorted(list, d, findGCompareFuncFct(comp));
 }
 EXPORT void* my_g_slist_insert_sorted_with_data(x64emu_t* emu, void* list, void* d, void* comp, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_slist_insert_sorted_with_data(list, d, findGCompareDataFuncFct(comp), data);
 }
 
 EXPORT void my_g_slist_foreach(x64emu_t* emu, void* list, void* func, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_slist_foreach(list, findGFuncFct(func), data);
 }
 
 EXPORT void* my_g_slist_find_custom(x64emu_t* emu, void* list, void* data, void* comp)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_slist_find_custom(list, data, findGCompareFuncFct(comp));
 }
 
 EXPORT uint32_t my_g_idle_add(x64emu_t* emu, void* func, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_idle_add(findGSourceFuncFct(func), data);
 }
 
 EXPORT void* my_g_variant_new_va(x64emu_t* emu, char* fmt, void* endptr, x64_va_list_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(*b);
     #else
@@ -1128,79 +1010,57 @@ EXPORT void* my_g_variant_new_va(x64emu_t* emu, char* fmt, void* endptr, x64_va_
 
 EXPORT void* my_g_variant_new(x64emu_t* emu, char* fmt, uint64_t* V)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     CREATE_VALIST_FROM_VAARG(V, emu->scratch, 1);
     return my->g_variant_new_va(fmt, NULL, &VARARGS);
 }
 
 EXPORT void* my_g_completion_new(x64emu_t* emu, void* f)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_completion_new(findGCompletionFct(f));
 }
 
 EXPORT void my_g_completion_set_compare(x64emu_t *emu, void* cmp, void* f)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     my->g_completion_set_compare(cmp, findGCompletionStrncmpFuncFct(f));
 }
 
 EXPORT void* my_g_log_set_default_handler(x64emu_t *emu, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return reverseGLogFuncFct(my->g_log_set_default_handler(findGLogFuncFct(f), data));
 }
 
 EXPORT uint32_t my_g_io_add_watch_full(x64emu_t* emu, void* channel, int priority, int cond, void* f, void* data, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_io_add_watch_full(channel, priority, cond, findGIOFuncFct(f), data, findDestroyFct(notify));
 }
 
 EXPORT uint32_t my_g_io_add_watch(x64emu_t* emu, void* channel, int cond, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_io_add_watch(channel, cond, findGIOFuncFct(f), data);
 }
 
 EXPORT void* my_g_set_print_handler(x64emu_t *emu, void* f)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return reverseGPrintFuncFct(my->g_set_print_handler(findGPrintFuncFct(f)));
 }
 
 EXPORT void* my_g_set_printerr_handler(x64emu_t *emu, void* f)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return reverseGPrintFuncFct(my->g_set_printerr_handler(findGPrintFuncFct(f)));
 }
 
 EXPORT void* my_g_slist_sort(x64emu_t *emu, void* list, void* f)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_slist_sort(list, findGCompareFuncFct(f));
 }
 
 EXPORT void* my_g_slist_sort_with_data(x64emu_t *emu, void* list, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_slist_sort_with_data(list, findGCompareDataFuncFct(f), data);
 }
 
 EXPORT void* my_g_build_path(x64emu_t *emu, void* sep, void* first, uintptr_t* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     int n = (first)?1:0;
     void* p = n?((void*)getVArgs(emu, 2, data, 0)):NULL;
     while(p) {
@@ -1218,63 +1078,46 @@ EXPORT void* my_g_build_path(x64emu_t *emu, void* sep, void* first, uintptr_t* d
 
 EXPORT void* my_g_list_sort(x64emu_t *emu, void* list, void* f)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_list_sort(list, findGCompareFuncFct(f));
 }
 
 EXPORT void* my_g_list_sort_with_data(x64emu_t *emu, void* list, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_list_sort_with_data(list, findGCompareDataFuncFct(f), data);
 }
 
 EXPORT void* my_g_queue_find_custom(x64emu_t *emu, void* queue, void* data, void* f)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_queue_find_custom(queue, data, findGCompareFuncFct(f));
 }
 
 EXPORT void* my_g_list_find_custom(x64emu_t *emu, void* list, void* data, void* f)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_list_find_custom(list, data, findGCompareFuncFct(f));
 }
 
 EXPORT uint32_t my_g_timeout_add_full(x64emu_t *emu, int priority, uint32_t interval, void* f, void* data, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_timeout_add_full(priority, interval, findGSourceFuncFct(f), data, findDestroyFct(notify));
 }
 
 EXPORT uint32_t my_g_timeout_add_seconds(x64emu_t *emu, uint32_t interval, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_timeout_add_seconds(interval, findGSourceFuncFct(f), data);
 }
 
 EXPORT uint32_t my_g_timeout_add_seconds_full(x64emu_t *emu, int priority, uint32_t interval, void* f, void* data, void* notify)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_timeout_add_seconds_full(priority, interval, findGSourceFuncFct(f), data, findDestroyFct(notify));
 }
 
 EXPORT uint32_t my_g_log_set_handler(x64emu_t *emu, void* domain, int level, void* f, void* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     return my->g_log_set_handler(domain, level, findGLogFuncFct(f), data);
 }
 
 EXPORT void my_g_set_error(x64emu_t *emu, void* err, void* domain, int code, void* fmt, uintptr_t* stack)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     char buf[1000];
     myStackAlign(emu, fmt, stack, emu->scratch, R_EAX, 4);
     PREPARE_VALIST;
@@ -1284,14 +1127,12 @@ EXPORT void my_g_set_error(x64emu_t *emu, void* err, void* domain, int code, voi
 
 EXPORT void* my_g_error_new(x64emu_t* emu, void* domain, int code, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
     return my->g_error_new_valist(domain, code, fmt, VARARGS);
 }
 EXPORT void* my_g_error_new_valist(x64emu_t* emu, void* domain, int code, void* fmt, x64_va_list_t V)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -1302,7 +1143,6 @@ EXPORT void* my_g_error_new_valist(x64emu_t* emu, void* domain, int code, void*
 
 EXPORT int my_g_fprintf(x64emu_t* emu, void* f, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
     return my->g_vfprintf(f, fmt, VARARGS);
@@ -1310,7 +1150,6 @@ EXPORT int my_g_fprintf(x64emu_t* emu, void* f, void* fmt, uintptr_t* b)
 
 EXPORT void my_g_logv(x64emu_t* emu, void* domain, int level, void* fmt, x64_va_list_t V)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -1320,7 +1159,6 @@ EXPORT void my_g_logv(x64emu_t* emu, void* domain, int level, void* fmt, x64_va_
 }
 EXPORT void my_g_log(x64emu_t* emu, void* domain, int level, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
     my->g_logv(domain, level, fmt, VARARGS);
@@ -1328,7 +1166,6 @@ EXPORT void my_g_log(x64emu_t* emu, void* domain, int level, void* fmt, uintptr_
 
 EXPORT int my_g_printf(x64emu_t* emu, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->g_vprintf(fmt, VARARGS);
@@ -1336,7 +1173,6 @@ EXPORT int my_g_printf(x64emu_t* emu, void* fmt, uintptr_t* b)
 
 EXPORT int my_g_snprintf(x64emu_t* emu, void* buf, size_t l, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
     return my->g_vsnprintf(buf, l, fmt, VARARGS);
@@ -1344,7 +1180,6 @@ EXPORT int my_g_snprintf(x64emu_t* emu, void* buf, size_t l, void* fmt, uintptr_
 
 EXPORT int my_g_sprintf(x64emu_t* emu, void* buf, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
     return my->g_vsprintf(buf, fmt, VARARGS);
@@ -1352,7 +1187,6 @@ EXPORT int my_g_sprintf(x64emu_t* emu, void* buf, void* fmt, uintptr_t* b)
 
 EXPORT void* my_g_strdup_printf(x64emu_t* emu, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->g_strdup_vprintf(fmt, VARARGS);
@@ -1360,7 +1194,6 @@ EXPORT void* my_g_strdup_printf(x64emu_t* emu, void* fmt, uintptr_t* b)
 
 EXPORT void my_g_string_append_printf(x64emu_t* emu, void* string, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
     return my->g_string_append_vprintf(string, fmt, VARARGS);
@@ -1368,7 +1201,6 @@ EXPORT void my_g_string_append_printf(x64emu_t* emu, void* string, void* fmt, ui
 
 EXPORT void my_g_string_append_vprintf(x64emu_t* emu, void* string, void* fmt, x64_va_list_t V)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -1380,7 +1212,6 @@ EXPORT void my_g_string_append_vprintf(x64emu_t* emu, void* string, void* fmt, x
 
 EXPORT void my_g_string_printf(x64emu_t* emu, void* string, void* fmt, uintptr_t* b)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     myStackAlign(emu, fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
     return my->g_string_vprintf(string, fmt, VARARGS);
@@ -1388,7 +1219,6 @@ EXPORT void my_g_string_printf(x64emu_t* emu, void* string, void* fmt, uintptr_t
 
 EXPORT void my_g_string_vprintf(x64emu_t* emu, void* string, void* fmt, x64_va_list_t V)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -1400,7 +1230,6 @@ EXPORT void my_g_string_vprintf(x64emu_t* emu, void* string, void* fmt, x64_va_l
 
 EXPORT void* my_g_strjoin(x64emu_t* emu, void* sep, uintptr_t* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     int n = 0;
     void* p = (void*)getVArgs(emu, 1, data, 0);
     while(p) {
@@ -1417,13 +1246,11 @@ EXPORT void* my_g_strjoin(x64emu_t* emu, void* sep, uintptr_t* data)
 
 EXPORT void* my_g_strjoinv(x64emu_t* emu, void* a, void** V)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     return my->g_strjoinv(a, V);
 }
 
 EXPORT void* my_g_option_group_new(x64emu_t* emu, void* name, void* desc, void* help, void* data, void* destroy)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     return my->g_option_group_new(name, desc, help, data, findDestroyFct(destroy));
 }
 
@@ -1439,7 +1266,6 @@ typedef struct my_GOptionEntry_s {
 
 EXPORT void my_g_option_context_add_main_entries(x64emu_t* emu, void* context, my_GOptionEntry_t* entries, void* domain)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
     my_GOptionEntry_t* p = entries;
     while (p->long_name) {
         // wrap Callbacks
@@ -1459,8 +1285,6 @@ EXPORT void my_g_option_context_add_main_entries(x64emu_t* emu, void* context, m
 
 EXPORT void* my_g_strconcat(x64emu_t* emu, void* first, uintptr_t* data)
 {
-    glib2_my_t *my = (glib2_my_t*)my_lib->priv.w.p2;
-
     int n = (first)?1:0;
     void* p = n?((void*)getVArgs(emu, 1, data, 0)):NULL;
     while(p) {
@@ -1482,14 +1306,11 @@ EXPORT void* my_g_strconcat(x64emu_t* emu, void* first, uintptr_t* data)
         return -1;
 
 #define CUSTOM_INIT \
-    libname = lib->name;\
     my_lib = lib;       \
-    lib->priv.w.p2 = getGlib2My(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeGlib2My(lib->priv.w.p2);\
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedgmodule2.c b/src/wrapped/wrappedgmodule2.c
index fb68612e..5e6510ff 100755
--- a/src/wrapped/wrappedgmodule2.c
+++ b/src/wrapped/wrappedgmodule2.c
@@ -20,8 +20,6 @@ const char* gmodule2Name = "libgmodule-2.0.so.0";
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libglib-2.0.so.0");
+    setNeededLibs(&lib->priv.w, 1, "libglib-2.0.so.0");
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedgnutls.c b/src/wrapped/wrappedgnutls.c
index ee446c20..e5418f96 100755
--- a/src/wrapped/wrappedgnutls.c
+++ b/src/wrapped/wrappedgnutls.c
@@ -21,32 +21,9 @@
 const char* gnutlsName = "libgnutls.so.30";
 #define LIBNAME gnutls
 
-static library_t *my_lib = NULL;
-
 #include "generated/wrappedgnutlstypes.h"
 
-typedef struct gnutls_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} gnutls_my_t;
-
-void* getGnutlsMy(library_t* lib)
-{
-    gnutls_my_t* my = (gnutls_my_t*)calloc(1, sizeof(gnutls_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeGnutlsMy(void* lib)
-{
-    (void)lib;
-    //gnutls_my_t *my = (gnutls_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 // utility functions
 #define SUPER() \
@@ -110,30 +87,24 @@ static void* find_pullpush_Fct(void* fct)
 EXPORT void my_gnutls_global_set_log_function(x64emu_t* emu, void* f)
 {
     (void)emu;
-    gnutls_my_t *my = (gnutls_my_t*)my_lib->priv.w.p2;
     my->gnutls_global_set_log_function(find_gnutls_log_Fct(f));
 }
 
 EXPORT void my_gnutls_transport_set_pull_function(x64emu_t* emu, void* session, void* f)
 {
     (void)emu;
-    gnutls_my_t *my = (gnutls_my_t*)my_lib->priv.w.p2;
     my->gnutls_transport_set_pull_function(session, find_pullpush_Fct(f));
 }
 EXPORT void my_gnutls_transport_set_push_function(x64emu_t* emu, void* session, void* f)
 {
     (void)emu;
-    gnutls_my_t *my = (gnutls_my_t*)my_lib->priv.w.p2;
     my->gnutls_transport_set_push_function(session, find_pullpush_Fct(f));
 }
 
 #define CUSTOM_INIT \
-    my_lib = lib;   \
-    lib->priv.w.p2 = getGnutlsMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    my_lib = NULL;  \
-    freeGnutlsMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedgobject2.c b/src/wrapped/wrappedgobject2.c
index 85d19086..f5eeb3df 100755
--- a/src/wrapped/wrappedgobject2.c
+++ b/src/wrapped/wrappedgobject2.c
@@ -21,7 +21,6 @@
 
 const char* gobject2Name = "libgobject-2.0.so.0";
 #define LIBNAME gobject2
-static library_t *my_lib = NULL;
 
 typedef size_t(*LFv_t)(void);
 typedef void*(*pFL_t)(size_t);
@@ -31,31 +30,11 @@ typedef void*(*pFL_t)(size_t);
  GO(g_type_name, pFL_t)
 
 #include "generated/wrappedgobject2types.h"
-
-typedef struct gobject2_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} gobject2_my_t;
-
 static void addGObject2Alternate(library_t* lib);
 
-void* getGobject2My(library_t* lib)
-{
-    gobject2_my_t* my = (gobject2_my_t*)calloc(1, sizeof(gobject2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    addGObject2Alternate(lib);
-    return my;
-}
-#undef SUPER
+#define ADDED_INIT()   addGObject2Alternate(lib);
 
-void freeGobject2My(void* lib)
-{
-    //gobject2_my_t *my = (gobject2_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 static int signal_cb(void* a, void* b, void* c, void* d, void* e)
 {
@@ -208,8 +187,6 @@ static void addGObject2Alternate(library_t* lib)
 
 EXPORT uintptr_t my_g_signal_connect_data(x64emu_t* emu, void* instance, void* detailed, void* c_handler, void* data, void* closure, uint32_t flags)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     //TODO: get the type of instance to be more precise below
 
     my_signal_t *sig = new_mysignal(c_handler, data, closure);
@@ -606,8 +583,6 @@ static void* findcompareFct(void* fct)
 
 EXPORT uintptr_t my_g_signal_connect_object(x64emu_t* emu, void* instance, void* detailed, void* c_handler, void* object, uint32_t flags)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     //TODO: get the type of instance to be more precise below
 
     return my->g_signal_connect_object(instance, detailed, findGCallbackFct(c_handler), object, flags);
@@ -615,7 +590,6 @@ EXPORT uintptr_t my_g_signal_connect_object(x64emu_t* emu, void* instance, void*
 
 EXPORT int my_g_boxed_type_register_static(x64emu_t* emu, void* name, void* boxed_copy, void* boxed_free)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     void* bc = findCopyFct(boxed_copy);
     void* bf = findFreeFct(boxed_free);
     return my->g_boxed_type_register_static(name, bc, bf);
@@ -623,8 +597,6 @@ EXPORT int my_g_boxed_type_register_static(x64emu_t* emu, void* name, void* boxe
 
 EXPORT uint32_t my_g_signal_new(x64emu_t* emu, void* name, size_t itype, int flags, uint32_t offset, void* acc, void* accu_data, void* marsh, size_t rtype, uint32_t n, void** b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     printf_log(LOG_DEBUG, "g_signal_new for \"%s\", with offset=%d and %d args\n", (const char*)name, offset, n);
     
     void* cb_acc = findAccumulatorFct(acc);
@@ -646,8 +618,6 @@ EXPORT uint32_t my_g_signal_new(x64emu_t* emu, void* name, size_t itype, int fla
 
 EXPORT uint32_t my_g_signal_newv(x64emu_t* emu, void* name, size_t itype, int flags, void* closure, void* acc, void* accu_data, void* marsh, size_t rtype, uint32_t n, void* types)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     printf_log(LOG_DEBUG, "g_signal_newv for \"%s\", with %d args\n", (const char*)name, n);
     
     return my->g_signal_newv(name, itype, flags, closure, findAccumulatorFct(acc), accu_data, findMarshalFct(marsh), rtype, n, types);
@@ -655,8 +625,6 @@ EXPORT uint32_t my_g_signal_newv(x64emu_t* emu, void* name, size_t itype, int fl
 
 EXPORT uint32_t my_g_signal_new_valist(x64emu_t* emu, void* name, size_t itype, int flags, void* closure, void* acc, void* accu_data, void* marsh, size_t rtype, uint32_t n, x64_va_list_t b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     printf_log(LOG_DEBUG, "g_signal_new_valist for \"%s\", with %d args\n", (const char*)name, n);
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
@@ -668,8 +636,6 @@ EXPORT uint32_t my_g_signal_new_valist(x64emu_t* emu, void* name, size_t itype,
 
 EXPORT uint32_t my_g_signal_handlers_block_matched(x64emu_t* emu, void* instance, int mask, uint32_t signal, void* detail, void* closure, void* fnc, void* data)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     // NOTE that I have no idea of the fnc signature!...
     if (fnc) printf_log(LOG_DEBUG, "Warning, gobject g_signal_handlers_block_matched called with non null function \n");
     fnc = findMarshalFct(fnc);  //... just in case
@@ -678,8 +644,6 @@ EXPORT uint32_t my_g_signal_handlers_block_matched(x64emu_t* emu, void* instance
 
 EXPORT uint32_t my_g_signal_handlers_unblock_matched(x64emu_t* emu, void* instance, int mask, uint32_t signal, void* detail, void* closure, void* fnc, void* data)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     // NOTE that I have no idea of the fnc signature!...
     if (fnc) printf_log(LOG_DEBUG, "Warning, gobject g_signal_handlers_unblock_matched called with non null function \n");
     fnc = findMarshalFct(fnc);  //... just in case
@@ -688,8 +652,6 @@ EXPORT uint32_t my_g_signal_handlers_unblock_matched(x64emu_t* emu, void* instan
 
 EXPORT uint32_t my_g_signal_handlers_disconnect_matched(x64emu_t* emu, void* instance, int mask, uint32_t signal, void* detail, void* closure, void* fnc, void* data)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     // NOTE that I have no idea of the fnc signature!...
     if (fnc) printf_log(LOG_DEBUG, "Warning, gobject g_signal_handlers_disconnect_matched called with non null function \n");
     fnc = findMarshalFct(fnc);  //... just in case
@@ -698,8 +660,6 @@ EXPORT uint32_t my_g_signal_handlers_disconnect_matched(x64emu_t* emu, void* ins
 
 EXPORT unsigned long my_g_signal_handler_find(x64emu_t* emu, void* instance, int mask, uint32_t signal, void* detail, void* closure, void* fnc, void* data)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     // NOTE that I have no idea of the fnc signature!...
     if (fnc) printf_log(LOG_DEBUG, "Warning, gobject g_signal_handler_find called with non null function \n");
     fnc = findMarshalFct(fnc);  //... just in case
@@ -708,7 +668,6 @@ EXPORT unsigned long my_g_signal_handler_find(x64emu_t* emu, void* instance, int
 
 EXPORT void* my_g_object_new(x64emu_t* emu, size_t type, void* first, void* b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     if(first) {
         CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
@@ -719,7 +678,6 @@ EXPORT void* my_g_object_new(x64emu_t* emu, size_t type, void* first, void* b)
 
 EXPORT void* my_g_object_new_valist(x64emu_t* emu, size_t type, void* first, x64_va_list_t b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -730,21 +688,18 @@ EXPORT void* my_g_object_new_valist(x64emu_t* emu, size_t type, void* first, x64
 
 EXPORT size_t my_g_type_register_static(x64emu_t* emu, size_t parent, void* name, my_GTypeInfo_t* info, int flags)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     return my->g_type_register_static(parent, name, findFreeGTypeInfo(info, parent), flags);
 }
 
 EXPORT size_t my_g_type_register_fundamental(x64emu_t* emu, size_t parent, void* name, my_GTypeInfo_t* info, void* finfo, int flags)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     return my->g_type_register_fundamental(parent, name, findFreeGTypeInfo(info, parent), finfo, flags);
 }
 
 EXPORT void my_g_value_register_transform_func(x64emu_t* emu, size_t src, size_t dst, void* f)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     my->g_value_register_transform_func(src, dst, findValueTransformFct(f));
 }
@@ -757,7 +712,6 @@ static int my_signal_emission_hook(void* ihint, uint32_t n, void* values, my_sig
 EXPORT unsigned long my_g_signal_add_emission_hook(x64emu_t* emu, uint32_t signal, void* detail, void* f, void* data, void* notify)
 {
     // there can be many signals connected, so something "light" is needed here
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     if(!f)
         return my->g_signal_add_emission_hook(signal, detail, f, data, notify);
@@ -787,8 +741,6 @@ typedef struct my_GInterfaceInfo_s {
 
 EXPORT void my_g_type_add_interface_static(x64emu_t* emu, size_t instance_type, size_t interface_type, my_GInterfaceInfo_t* info)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
-
     my_GInterfaceInfo_t i = {0};
     i.interface_init = findGInterfaceInitFuncFct(info->interface_init);
     i.interface_finalize = findGInterfaceFinalizeFuncFct(info->interface_finalize);
@@ -798,42 +750,36 @@ EXPORT void my_g_type_add_interface_static(x64emu_t* emu, size_t instance_type,
 
 EXPORT void my_g_param_spec_set_qdata_full(x64emu_t* emu, void* pspec, uint32_t quark, void* data, void* notify)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     my->g_param_spec_set_qdata_full(pspec, quark, data, findFreeFct(notify));
 }
 
 EXPORT int my_g_param_type_register_static(x64emu_t* emu, void* name, void* pspec_info)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     return my->g_param_type_register_static(name, findFreeGParamSpecTypeInfo(pspec_info));
 }
 
 EXPORT void* my_g_value_array_sort(x64emu_t* emu, void* array, void* comp)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     return my->g_value_array_sort(array, findcompareFct(comp));
 }
 
 EXPORT void* my_g_value_array_sort_with_data(x64emu_t* emu, void* array, void* comp, void* data)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     return my->g_value_array_sort_with_data(array, findcompareFct(comp), data);
 }
 
 EXPORT void my_g_object_set_data_full(x64emu_t* emu, void* object, void* key, void* data, void* notify)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     my->g_object_set_data_full(object, key, data, findFreeFct(notify));
 }
 
 EXPORT void* my_g_type_class_peek_parent(x64emu_t* emu, void* object)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
 
     void* klass = my->g_type_class_peek_parent(object);
     size_t type = klass?*(size_t*)klass:0;
@@ -842,7 +788,6 @@ EXPORT void* my_g_type_class_peek_parent(x64emu_t* emu, void* object)
 
 EXPORT void my_g_signal_emit_valist(x64emu_t* emu, void* inst, uint32_t id, void* quark, x64_va_list_t b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -853,14 +798,12 @@ EXPORT void my_g_signal_emit_valist(x64emu_t* emu, void* inst, uint32_t id, void
 
 EXPORT void my_g_signal_emit(x64emu_t* emu, void* inst, uint32_t id, void* quark, x64_va_list_t b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 3);
     my->g_signal_emit_valist(inst, id, quark, VARARGS);
 }
 
 EXPORT void my_g_object_get_valist(x64emu_t* emu, void* a1, void* a2, x64_va_list_t b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -871,7 +814,6 @@ EXPORT void my_g_object_get_valist(x64emu_t* emu, void* a1, void* a2, x64_va_lis
 
 EXPORT void my_g_object_get(x64emu_t* emu, void* a1, void* a2, uintptr_t* b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     my->g_object_get_valist(a1, a2, VARARGS);
 }
@@ -879,7 +821,6 @@ EXPORT void my_g_object_get(x64emu_t* emu, void* a1, void* a2, uintptr_t* b)
 
 EXPORT void my_g_object_set_valist(x64emu_t* emu, void* a1, void* a2, x64_va_list_t b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -890,26 +831,22 @@ EXPORT void my_g_object_set_valist(x64emu_t* emu, void* a1, void* a2, x64_va_lis
 
 EXPORT void my_g_object_set(x64emu_t* emu, void* a1, void* a2, uintptr_t* b)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     my->g_object_set_valist(a1, a2, VARARGS);
 }
 
 EXPORT void my_g_object_set_qdata_full(x64emu_t* emu, void* o, void* q, void* data, void* d)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     my->g_object_set_qdata_full(o, q, data, findDestroyFct(d));
 }
 
 EXPORT void my_g_object_class_install_properties(x64emu_t* emu, void* klass, uint32_t n, void* specs)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     my->g_object_class_install_properties(unwrapCopyGTKClass(klass, my->g_object_get_type()), n, specs);
 }
 
 EXPORT void my_g_object_weak_ref(x64emu_t* emu, void* object, void* notify, void* data)
 {
-    gobject2_my_t *my = (gobject2_my_t*)my_lib->priv.w.p2;
     my->g_object_weak_ref(object, findWeakNotifyFct(notify), data);
 }
 
@@ -918,20 +855,15 @@ EXPORT void my_g_object_weak_ref(x64emu_t* emu, void* object, void* notify, void
         return -1;
 
 #define CUSTOM_INIT \
-    InitGTKClass(lib->priv.w.bridge);           \
-    lib->priv.w.p2 = getGobject2My(lib);        \
-    my_lib = lib;                               \
-    SetGObjectID(((gobject2_my_t*)lib->priv.w.p2)->g_object_get_type());        \
-    SetGTypeName(((gobject2_my_t*)lib->priv.w.p2)->g_type_name);                \
-    lib->priv.w.needed = 1;                     \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libglib-2.0.so.0");
+    InitGTKClass(lib->priv.w.bridge);       \
+    getMy(lib);                             \
+    SetGObjectID(my->g_object_get_type());  \
+    SetGTypeName(my->g_type_name);          \
+    setNeededLibs(&lib->priv.w, 1, "libglib-2.0.so.0");
 
 #define CUSTOM_FINI \
-    FiniGTKClass();                 \
-    freeGobject2My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);           \
-    my_lib = NULL;
+    FiniGTKClass(); \
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedgstreamer.c b/src/wrapped/wrappedgstreamer.c
index ff2a5c1d..3c9dd197 100644
--- a/src/wrapped/wrappedgstreamer.c
+++ b/src/wrapped/wrappedgstreamer.c
@@ -18,7 +18,6 @@
 #include "emu/x64emu_private.h"
 #include "myalign.h"
 
-static library_t *my_lib = NULL;
 const char* gstreamerName = "libgstreamer-1.0.so.0";
 #define LIBNAME gstreamer
 
@@ -26,29 +25,7 @@ const char* gstreamerName = "libgstreamer-1.0.so.0";
 
 #include "generated/wrappedgstreamertypes.h"
 
-typedef struct gstreamer_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} gstreamer_my_t;
-
-static void addGObject2Alternate(library_t* lib);
-
-static void* getGstreamerMy(library_t* lib)
-{
-    gstreamer_my_t* my = (gstreamer_my_t*)calloc(1, sizeof(gstreamer_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-static void freeGstreamerMy(void* lib)
-{
-    //gstreamer_my_t *my = (gstreamer_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -217,14 +194,12 @@ static void* findGstBusSyncHandlerFct(void* fct)
 #undef SUPER
 
 EXPORT void my_gst_caps_set_simple(x64emu_t* emu, void* caps, void* field, void* b) {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
 
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     my->gst_caps_set_simple_valist(caps, field, VARARGS);
 }
 
 EXPORT void my_gst_caps_set_simple_valist(x64emu_t* emu, void* caps, void* field, x64_va_list_t V) {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -234,14 +209,12 @@ EXPORT void my_gst_caps_set_simple_valist(x64emu_t* emu, void* caps, void* field
 }
 
 EXPORT void my_gst_structure_remove_fields(x64emu_t* emu, void* structure, void* field, void* b) {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
 
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     my->gst_structure_remove_fields_valist(structure, field, VARARGS);
 }
 
 EXPORT void my_gst_structure_remove_fields_valist(x64emu_t* emu, void* structure, void* field, x64_va_list_t V) {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -251,7 +224,6 @@ EXPORT void my_gst_structure_remove_fields_valist(x64emu_t* emu, void* structure
 }
 
 EXPORT void my_gst_debug_log(x64emu_t* emu, void* cat, int level, void* file, void* func, int line, void* obj, void* fmt, void* b) {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
 
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 7);
     PREPARE_VALIST;
@@ -259,7 +231,6 @@ EXPORT void my_gst_debug_log(x64emu_t* emu, void* cat, int level, void* file, vo
 }
 
 EXPORT void my_gst_debug_log_valist(x64emu_t* emu, void* cat, int level, void* file, void* func, int line, void* obj, void* fmt, x64_va_list_t V) {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
 
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
@@ -271,14 +242,12 @@ EXPORT void my_gst_debug_log_valist(x64emu_t* emu, void* cat, int level, void* f
 }
 
 EXPORT int my_gst_structure_get(x64emu_t* emu, void* structure, void* field, void* b) {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
 
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     return my->gst_structure_get_valist(structure, field, VARARGS);
 }
 
 EXPORT int my_gst_structure_get_valist(x64emu_t* emu, void* structure, void* field, x64_va_list_t V) {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -290,37 +259,31 @@ EXPORT int my_gst_structure_get_valist(x64emu_t* emu, void* structure, void* fie
 
 EXPORT void my_gst_pad_set_activatemode_function_full(x64emu_t* emu, void* pad, void* f, void* data, void* d)
 {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     my->gst_pad_set_activatemode_function_full(pad, findGstPadActivateModeFunctionFct(f), data, findDestroyFct(d));
 }
 
 EXPORT void my_gst_pad_set_query_function_full(x64emu_t* emu, void* pad, void* f, void* data, void* d)
 {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     my->gst_pad_set_query_function_full(pad, findGstPadQueryFunctionFct(f), data, findDestroyFct(d));
 }
 
 EXPORT void my_gst_pad_set_getrange_function_full(x64emu_t* emu, void* pad, void* f, void* data, void* d)
 {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     my->gst_pad_set_getrange_function_full(pad, findGstPadGetRangeFunctionFct(f), data, findDestroyFct(d));
 }
 
 EXPORT void my_gst_pad_set_chain_function_full(x64emu_t* emu, void* pad, void* f, void* data, void* d)
 {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     my->gst_pad_set_chain_function_full(pad, findGstPadChainFunctionFct(f), data, findDestroyFct(d));
 }
 
 EXPORT void my_gst_pad_set_event_function_full(x64emu_t* emu, void* pad, void* f, void* data, void* d)
 {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     my->gst_pad_set_event_function_full(pad, findGstPadEventFunctionFct(f), data, findDestroyFct(d));
 }
 
 EXPORT void my_gst_bus_set_sync_handler(x64emu_t* emu, void* bus, void* f, void* data, void* d)
 {
-    gstreamer_my_t *my = (gstreamer_my_t*)my_lib->priv.w.p2;
     my->gst_bus_set_sync_handler(bus, findGstBusSyncHandlerFct(f), data, findDestroyFct(d));
 }
 
@@ -329,12 +292,9 @@ EXPORT void my_gst_bus_set_sync_handler(x64emu_t* emu, void* bus, void* f, void*
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getGstreamerMy(lib);        \
-    my_lib = lib;                               \
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeGstreamerMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);           \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedgthread2.c b/src/wrapped/wrappedgthread2.c
index b992e0b4..6e66c729 100755
--- a/src/wrapped/wrappedgthread2.c
+++ b/src/wrapped/wrappedgthread2.c
@@ -22,33 +22,11 @@
 const char* gthread2Name = "libgthread-2.0.so.0";
 #define LIBNAME gthread2
 
-typedef void  (*vFp_t)(void*);
+#define ADDED_FUNCTIONS() \
 
-#define SUPER() \
-    GO(g_thread_init, vFp_t)                            \
-    GO(g_thread_init_with_errorcheck_mutexes, vFp_t)
+#include "wrappedgthread2types.h"
 
-typedef struct gthread2_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} gthread2_my_t;
-
-void* getGthread2My(library_t* lib)
-{
-    gthread2_my_t* my = (gthread2_my_t*)calloc(1, sizeof(gthread2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeGthread2My(void* lib)
-{
-    //gthread2_my_t *my = (gthread2_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 EXPORT int g_threads_got_initialized;
 
@@ -85,9 +63,6 @@ EXPORT void my_g_thread_init(x64emu_t* emu, my_GThreadFunctions_t* vtable)
         return;
     }
 
-    library_t * lib = GetLibInternal(gthread2Name);
-    gthread2_my_t *my = (gthread2_my_t*)lib->priv.w.p2;
-
     if(!vtable)
         return my->g_thread_init(NULL);
 
@@ -107,9 +82,6 @@ EXPORT void my_g_thread_init_with_errorcheck_mutexes(x64emu_t* emu, my_GThreadFu
         return;
     }
 
-    library_t * lib = GetLibInternal(gthread2Name);
-    gthread2_my_t *my = (gthread2_my_t*)lib->priv.w.p2;
-
     if(vtable)
         printf_log(LOG_NONE, "Warning, vtable is not NULL in g_thread_init_with_errorcheck_mutexes call!\n");
     
@@ -131,11 +103,10 @@ void** my_GetGthreadsGotInitialized()
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getGthread2My(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeGthread2My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedgtkx112.c b/src/wrapped/wrappedgtkx112.c
index 8769e863..aafddfc2 100755
--- a/src/wrapped/wrappedgtkx112.c
+++ b/src/wrapped/wrappedgtkx112.c
@@ -21,7 +21,6 @@
 
 const char* gtkx112Name = "libgtk-x11-2.0.so.0";
 static char* libname = NULL;
-static library_t* my_lib = NULL;
 #define LIBNAME gtkx112
 
 typedef size_t        (*LFv_t)(void);
@@ -83,40 +82,19 @@ typedef unsigned long (*LFpppppi_t)(void*, void*, void*, void*, void*, int);
 
 #include "generated/wrappedgtkx112types.h"
 
-
-typedef struct gtkx112_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
+#define ADDED_STRUCT() \
     int  gtk1;
-} gtkx112_my_t;
 
-void* getGtkx112My(library_t* lib)
-{
-    my_lib = lib;
-    gtkx112_my_t* my = (gtkx112_my_t*)calloc(1, sizeof(gtkx112_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    if(strcmp(lib->name, "libgtk-1.2.so.0")==0)
+#define ADDED_INIT()                            \
+    if(strcmp(lib->name, "libgtk-1.2.so.0")==0) \
         my->gtk1 = 1;
-    return my;
-}
-#undef SUPER
 
-void freeGtkx112My(void* lib)
-{
-    //gtkx112_my_t *my = (gtkx112_my_t *)lib;
-    my_lib = NULL;
-}
+#include "wrappercallback.h"
 
 static box64context_t* context = NULL;
 
 EXPORT uintptr_t my_gtk_signal_connect_full(x64emu_t* emu, void* object, void* name, void* c_handler, void* unsupported, void* data, void* closure, uint32_t signal, int after)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     if(!context)
         context = emu->context;
 
@@ -667,8 +645,6 @@ static void* reverse_GtkLinkButtonUri_Fct(void* fct)
 
 EXPORT void my_gtk_dialog_add_buttons(x64emu_t* emu, void* dialog, void* first, uintptr_t* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     void* btn = first;
     int n = 0;
     while(btn) {
@@ -680,8 +656,6 @@ EXPORT void my_gtk_dialog_add_buttons(x64emu_t* emu, void* dialog, void* first,
 
 EXPORT void my_gtk_message_dialog_format_secondary_text(x64emu_t* emu, void* dialog, void* fmt, void* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
@@ -694,8 +668,6 @@ EXPORT void my_gtk_message_dialog_format_secondary_text(x64emu_t* emu, void* dia
 
 EXPORT void my_gtk_message_dialog_format_secondary_markup(x64emu_t* emu, void* dialog, void* fmt, void* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
@@ -708,8 +680,6 @@ EXPORT void my_gtk_message_dialog_format_secondary_markup(x64emu_t* emu, void* d
 
 EXPORT void my_gtk_list_store_set_valist(x64emu_t* emu, void* list, void* iter, x64_va_list_t V)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -720,16 +690,12 @@ EXPORT void my_gtk_list_store_set_valist(x64emu_t* emu, void* list, void* iter,
 
 EXPORT void my_gtk_list_store_set(x64emu_t* emu, void* list, void* iter, uintptr_t* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     my->gtk_list_store_set_valist(list, iter, VARARGS);
 }
 
 EXPORT void my_gtk_widget_style_get_valist(x64emu_t* emu, void* widget, void* first, x64_va_list_t V)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -740,24 +706,18 @@ EXPORT void my_gtk_widget_style_get_valist(x64emu_t* emu, void* widget, void* fi
 
 EXPORT void my_gtk_widget_style_get(x64emu_t* emu, void* widget, void* first, uintptr_t* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     my->gtk_widget_style_get_valist(widget, first, VARARGS);
 }
 
 EXPORT void* my_gtk_type_class(x64emu_t* emu, size_t type)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     void* class = my->gtk_type_class(type);
     return wrapCopyGTKClass(class, type);
 }
 
 EXPORT void my_gtk_init(x64emu_t* emu, void* argc, void* argv)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_init(argc, argv);
     my_checkGlobalGdkDisplay();
     AutoBridgeGtk(my->g_type_class_ref, my->g_type_class_unref);
@@ -765,8 +725,6 @@ EXPORT void my_gtk_init(x64emu_t* emu, void* argc, void* argv)
 
 EXPORT int my_gtk_init_check(x64emu_t* emu, void* argc, void* argv)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     int ret = my->gtk_init_check(argc, argv);
     my_checkGlobalGdkDisplay();
     AutoBridgeGtk(my->g_type_class_ref, my->g_type_class_unref);
@@ -775,8 +733,6 @@ EXPORT int my_gtk_init_check(x64emu_t* emu, void* argc, void* argv)
 
 EXPORT int my_gtk_init_with_args(x64emu_t* emu, void* argc, void* argv, void* param, void* entries, void* trans, void* error)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     int ret = my->gtk_init_with_args(argc, argv, param, entries, trans, error);
     my_checkGlobalGdkDisplay();
     AutoBridgeGtk(my->g_type_class_ref, my->g_type_class_unref);
@@ -785,36 +741,26 @@ EXPORT int my_gtk_init_with_args(x64emu_t* emu, void* argc, void* argv, void* pa
 
 EXPORT void my_gtk_menu_attach_to_widget(x64emu_t* emu, void* menu, void* widget, void* f)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_menu_attach_to_widget(menu, widget, findMenuDetachFct(f));
 }
 
 EXPORT void my_gtk_menu_popup(x64emu_t* emu, void* menu, void* shell, void* item, void* f, void* data, uint32_t button, uint32_t time_)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_menu_popup(menu, shell, item, findMenuPositionFct(f), data, button, time_);
 }
 
 EXPORT uint32_t my_gtk_timeout_add(x64emu_t* emu, uint32_t interval, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_timeout_add(interval, findGtkFunctionFct(f), data);
 }
 
 EXPORT int my_gtk_clipboard_set_with_data(x64emu_t* emu, void* clipboard, void* target, uint32_t n, void* f_get, void* f_clear, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_clipboard_set_with_data(clipboard, target, n, findClipboadGetFct(f_get), findClipboadClearFct(f_clear), data);
 }
 
 EXPORT int my_gtk_clipboard_set_with_owner(x64emu_t* emu, void* clipboard, void* target, uint32_t n, void* f_get, void* f_clear, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_clipboard_set_with_owner(clipboard, target, n, findClipboadGetFct(f_get), findClipboadClearFct(f_clear), data);
 }
 
@@ -825,107 +771,77 @@ static void* my_translate_func(void* path, my_signal_t* sig)
 
 EXPORT void my_gtk_stock_set_translate_func(x64emu_t* emu, void* domain, void* f, void* data, void* notify)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my_signal_t *sig = new_mysignal(f, data, notify);
     my->gtk_stock_set_translate_func(domain, my_translate_func, sig, my_signal_delete);
 }
 
 EXPORT void my_gtk_container_forall(x64emu_t* emu, void* container, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_container_forall(container, findGtkCallbackFct(f), data);
 }
 
 EXPORT void my_gtk_tree_view_set_search_equal_func(x64emu_t* emu, void* tree_view, void* f, void* data, void* notify)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_tree_view_set_search_equal_func(tree_view, findGtkTreeViewSearchEqualFuncFct(f), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT int my_gtk_text_iter_backward_find_char(x64emu_t* emu, void* iter, void* f, void* data, void* limit)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_text_iter_backward_find_char(iter, findGtkTextCharPredicateFct(f), data, limit);
 }
 
 EXPORT int my_gtk_text_iter_forward_find_char(x64emu_t* emu, void* iter, void* f, void* data, void* limit)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_text_iter_forward_find_char(iter, findGtkTextCharPredicateFct(f), data, limit);
 }
 
 EXPORT void* my_gtk_toolbar_append_item(x64emu_t* emu, void* toolbar, void* text, void* tooltip_text, void* tooltip_private, void* icon, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_toolbar_append_item(toolbar, text, tooltip_text, tooltip_private, icon, findToolbarFct(f), data);
 }
 
 EXPORT void* my_gtk_toolbar_prepend_item(x64emu_t* emu, void* toolbar, void* text, void* tooltip_text, void* tooltip_private, void* icon, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_toolbar_prepend_item(toolbar, text, tooltip_text, tooltip_private, icon, findToolbarFct(f), data);
 }
 
 EXPORT void* my_gtk_toolbar_insert_item(x64emu_t* emu, void* toolbar, void* text, void* tooltip_text, void* tooltip_private, void* icon, void* f, void* data, int position)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_toolbar_insert_item(toolbar, text, tooltip_text, tooltip_private, icon, findToolbarFct(f), data, position);
 }
 
 EXPORT void* my_gtk_toolbar_append_element(x64emu_t* emu, void* toolbar, size_t type, void* widget, void* text, void* tooltip_text, void* tooltip_private, void* icon, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_toolbar_append_element(toolbar, type, widget, text, tooltip_text, tooltip_private, icon, findToolbarFct(f), data);
 }
 
 EXPORT void* my_gtk_toolbar_prepend_element(x64emu_t* emu, void* toolbar, size_t type, void* widget, void* text, void* tooltip_text, void* tooltip_private, void* icon, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_toolbar_prepend_element(toolbar, type, widget, text, tooltip_text, tooltip_private, icon, findToolbarFct(f), data);
 }
 
 EXPORT void* my_gtk_toolbar_insert_element(x64emu_t* emu, void* toolbar, size_t type, void* widget, void* text, void* tooltip_text, void* tooltip_private, void* icon, void* f, void* data, int position)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_toolbar_insert_element(toolbar, type, widget, text, tooltip_text, tooltip_private, icon, findToolbarFct(f), data, position);
 }
 
 EXPORT void* my_gtk_toolbar_insert_stock(x64emu_t* emu, void* toolbar, void* stock_id, void* tooltip_text, void* tooltip_private, void* f, void* data, int position)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_toolbar_insert_stock(toolbar, stock_id, tooltip_text, tooltip_private, findToolbarFct(f), data, position);
 }
 
 EXPORT void my_gtk_tree_sortable_set_sort_func(x64emu_t* emu, void* sortable, int id, void* f, void* data, void* notify)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_tree_sortable_set_sort_func(sortable, id, findGtkTreeIterCompareFuncFct(f), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT void my_gtk_tree_sortable_set_default_sort_func(x64emu_t* emu, void* sortable, void* f, void* data, void* notify)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_tree_sortable_set_default_sort_func(sortable, findGtkTreeIterCompareFuncFct(f), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT size_t my_gtk_type_unique(x64emu_t* emu, size_t parent, my_GtkTypeInfo_t* gtkinfo)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_type_unique((void*)parent, findFreeGtkTypeInfo(gtkinfo, parent));
 }
 
@@ -936,15 +852,11 @@ EXPORT unsigned long my_gtk_signal_connect(x64emu_t* emu, void* object, void* na
 
 EXPORT void my_gtk_object_set_data_full(x64emu_t* emu, void* object, void* key, void* data, void* notify)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_object_set_data_full(object, key, data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT float my_gtk_spin_button_get_value_as_float(x64emu_t* emu, void* spinner)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_spin_button_get_value(spinner);
 }
 
@@ -963,8 +875,6 @@ typedef struct dummy_gtk1_button_s {
 
 EXPORT void* my_gtk_type_check_object_cast(x64emu_t* emu, void* obj, size_t type)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     if(my->gtk1 && type==my->gtk_bin_get_type())
     {
         // check if obj is a button...
@@ -986,8 +896,6 @@ EXPORT void* my_gtk_type_check_object_cast(x64emu_t* emu, void* obj, size_t type
 
 EXPORT void my_gtk_builder_connect_signals_full(x64emu_t* emu, void* builder, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_builder_connect_signals_full(builder, findBuilderConnectFct(f), data);
 }
 
@@ -998,7 +906,6 @@ typedef struct my_GSList_s {
 
 EXPORT void my_gtk_binding_entry_add_signal(x64emu_t* emu, void* binding, uint32_t keyval, int mod, void* name, uint32_t n, uintptr_t* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
     if(!n) {
         my->gtk_binding_entry_add_signal(binding, keyval, mod, name, 0);
         return;
@@ -1017,22 +924,16 @@ EXPORT void my_gtk_binding_entry_add_signal(x64emu_t* emu, void* binding, uint32
 
 EXPORT void my_gtk_container_foreach(x64emu_t* emu, void* container, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_container_foreach(container, findGtkCallbackFct(f), data);
 }
 
 EXPORT void my_gtk_cell_layout_set_cell_data_func(x64emu_t* emu, void* layout, void* cell, void* f, void* data, void* notify)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_cell_layout_set_cell_data_func(layout, cell, findGtkCellLayoutDataFuncFct(f), data, findGDestroyNotifyFct(notify));
 }
 
 EXPORT void my_gtk_tree_view_column_set_cell_data_func(x64emu_t* emu, void* column, void* cell, void* f, void* data, void* notify)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_tree_view_column_set_cell_data_func(column, cell, findGtkTreeCellDataFuncFct(f), data, findGDestroyNotifyFct(notify));
 }
 
@@ -1085,8 +986,6 @@ static void my_gtk_builder_connect_signals_custom(void* builder,
 
 EXPORT void my_gtk_builder_connect_signals(x64emu_t* emu, void* builder, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my_ConnectArgs_t args;
 
     args.my = my;
@@ -1110,8 +1009,6 @@ typedef struct my_GtkActionEntry_s {
 
 EXPORT void my_gtk_action_group_add_actions(x64emu_t* emu, void* action_group, my_GtkActionEntry_t* entries, uint32_t n, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my_GtkActionEntry_t myentries[n];
     memcpy(myentries, entries, n*sizeof(my_GtkActionEntry_t));
     for(uint32_t i=0; i<n; ++i)
@@ -1121,8 +1018,6 @@ EXPORT void my_gtk_action_group_add_actions(x64emu_t* emu, void* action_group, m
 
 EXPORT void my_gtk_action_group_add_actions_full(x64emu_t* emu, void* action_group, my_GtkActionEntry_t* entries, uint32_t n, void* data, void* destroy)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my_GtkActionEntry_t myentries[n];
     memcpy(myentries, entries, n*sizeof(my_GtkActionEntry_t));
     for(uint32_t i=0; i<n; ++i)
@@ -1132,44 +1027,32 @@ EXPORT void my_gtk_action_group_add_actions_full(x64emu_t* emu, void* action_gro
 
 EXPORT void my_gtk_tree_model_foreach(x64emu_t* emu, void* model, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_tree_model_foreach(model, findGtkTreeModelForeachFuncFct(f), data);
 }
 
 EXPORT void my_gtk_tree_selection_selected_foreach(x64emu_t* emu, void* selection, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_tree_selection_selected_foreach(selection, findGtkTreeSelectionSelectedForeachFuncFct(f), data);
 }
 
 EXPORT void my_gtk_clipboard_request_contents(x64emu_t* emu, void* clipboard, void* target, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_clipboard_request_contents(clipboard, target, findGtkClipboardReceivedFuncFct(f), data);
 }
 
 
 EXPORT void my_gtk_clipboard_request_text(x64emu_t* emu, void* clipboard, void* f, void* data)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     my->gtk_clipboard_request_text(clipboard, findGtkClipboardTextReceivedFuncFct(f), data);
 }
 
 EXPORT uint32_t my_gtk_input_add_full(x64emu_t* emu, int source, int condition, void* func, void* marshal, void* data, void* destroy)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     return my->gtk_input_add_full(source, condition, findGdkInputFunctionFct(func), findGtkCallbackMarshalFct(marshal), data, findGDestroyNotifyFct(destroy));
 }
 
 EXPORT void my_gtk_list_store_insert_with_values(x64emu_t* emu, void* store, void* iter, int pos, uintptr_t* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 3);
     // not 100% exact, but better than nothing
     my->gtk_list_store_insert(store, iter, pos);
@@ -1180,8 +1063,6 @@ EXPORT void my_gtk_list_store_insert_with_values(x64emu_t* emu, void* store, voi
 
 EXPORT void* my_gtk_list_store_new(x64emu_t* emu, int n, uintptr_t* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     uintptr_t a[n];
     for(int i=0; i<n; ++i)
         a[i] = getVArgs(emu, 1, b, i);
@@ -1190,8 +1071,6 @@ EXPORT void* my_gtk_list_store_new(x64emu_t* emu, int n, uintptr_t* b)
 
 EXPORT void* my_gtk_tree_store_new(x64emu_t* emu, int n, uintptr_t* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     uintptr_t a[n];
     for(int i=0; i<n; ++i)
         a[i] = getVArgs(emu, 1, b, i);
@@ -1200,8 +1079,6 @@ EXPORT void* my_gtk_tree_store_new(x64emu_t* emu, int n, uintptr_t* b)
 
 EXPORT void my_gtk_tree_model_get_valist(x64emu_t* emu, void* tree, void* iter, x64_va_list_t V)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(V);
     #else
@@ -1212,16 +1089,12 @@ EXPORT void my_gtk_tree_model_get_valist(x64emu_t* emu, void* tree, void* iter,
 
 EXPORT void my_gtk_tree_model_get(x64emu_t* emu, void* tree, void* iter, uintptr_t* b)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     CREATE_VALIST_FROM_VAARG(b, emu->scratch, 2);
     my->gtk_tree_model_get_valist(tree, iter, VARARGS);
 }
 
 EXPORT void* my_gtk_link_button_set_uri_hook(x64emu_t* emu, void* f, void* data, void* d)
 {
-    gtkx112_my_t *my = (gtkx112_my_t*)my_lib->priv.w.p2;
-
     void* ret = my->gtk_link_button_set_uri_hook(find_GtkLinkButtonUri_Fct(f), data, findGDestroyNotifyFct(d));
     return reverse_GtkLinkButtonUri_Fct(ret);
 }
@@ -1231,37 +1104,33 @@ EXPORT void* my_gtk_link_button_set_uri_hook(x64emu_t* emu, void* f, void* data,
         return -1;
 
 #define CUSTOM_INIT \
-    libname = lib->name;                \
-    lib->priv.w.p2 = getGtkx112My(lib); \
-    SetGtkObjectID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_object_get_type());     \
-    SetGtkWidgetID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_widget_get_type());     \
-    SetGtkContainerID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_container_get_type());\
-    SetGtkActionID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_action_get_type());     \
-    SetGtkMiscID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_misc_get_type());         \
-    SetGtkLabelID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_label_get_type());       \
-    SetGtkTreeViewID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_tree_view_get_type());\
-    SetGtkBinID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_bin_get_type());           \
-    SetGtkWindowID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_window_get_type());     \
-    SetGtkTableID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_table_get_type());       \
-    SetGtkFixedID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_fixed_get_type());       \
-    SetGtkButtonID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_button_get_type());     \
-    SetGtkComboBoxID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_combo_box_get_type());\
-    SetGtkToggleButtonID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_toggle_button_get_type());\
-    SetGtkCheckButtonID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_check_button_get_type());\
-    SetGtkEntryID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_entry_get_type());       \
-    SetGtkSpinButtonID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_spin_button_get_type());\
-    SetGtkProgressID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_progress_get_type()); \
-    SetGtkProgressBarID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_progress_bar_get_type());\
-    SetGtkFrameID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_frame_get_type());       \
-    SetGtkMenuShellID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_menu_shell_get_type()); \
-    SetGtkMenuBarID(((gtkx112_my_t*)lib->priv.w.p2)->gtk_menu_bar_get_type());  \
-    lib->priv.w.needed = 2;                                                     \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libgdk-x11-2.0.so.0");                  \
-    lib->priv.w.neededlibs[1] = strdup("libpangocairo-1.0.so.0");
+    libname = lib->name;                                                        \
+    getMy(lib);                                                                 \
+    SetGtkObjectID(my->gtk_object_get_type());                                  \
+    SetGtkWidgetID(my->gtk_widget_get_type());                                  \
+    SetGtkContainerID(my->gtk_container_get_type());                            \
+    SetGtkActionID(my->gtk_action_get_type());                                  \
+    SetGtkMiscID(my->gtk_misc_get_type());                                      \
+    SetGtkLabelID(my->gtk_label_get_type());                                    \
+    SetGtkTreeViewID(my->gtk_tree_view_get_type());                             \
+    SetGtkBinID(my->gtk_bin_get_type());                                        \
+    SetGtkWindowID(my->gtk_window_get_type());                                  \
+    SetGtkTableID(my->gtk_table_get_type());                                    \
+    SetGtkFixedID(my->gtk_fixed_get_type());                                    \
+    SetGtkButtonID(my->gtk_button_get_type());                                  \
+    SetGtkComboBoxID(my->gtk_combo_box_get_type());                             \
+    SetGtkToggleButtonID(my->gtk_toggle_button_get_type());                     \
+    SetGtkCheckButtonID(my->gtk_check_button_get_type());                       \
+    SetGtkEntryID(my->gtk_entry_get_type());                                    \
+    SetGtkSpinButtonID(my->gtk_spin_button_get_type());                         \
+    SetGtkProgressID(my->gtk_progress_get_type());                              \
+    SetGtkProgressBarID(my->gtk_progress_bar_get_type());                       \
+    SetGtkFrameID(my->gtk_frame_get_type());                                    \
+    SetGtkMenuShellID(my->gtk_menu_shell_get_type());                           \
+    SetGtkMenuBarID(my->gtk_menu_bar_get_type());                               \
+    setNeededLibs(&lib->priv.w, 2, "libgdk-x11-2.0.so.0", "libpangocairo-1.0.so.0");
 
 #define CUSTOM_FINI \
-    freeGtkx112My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedkrb5.c b/src/wrapped/wrappedkrb5.c
index 851097bc..26419814 100755
--- a/src/wrapped/wrappedkrb5.c
+++ b/src/wrapped/wrappedkrb5.c
@@ -18,34 +18,12 @@
 
 const char* krb5Name = "libkrb5.so.3";
 #define LIBNAME krb5
-static library_t *my_lib = NULL;
 
-typedef int     (*iFppppppipp_t)      (void*, void*, void*, void*, void*, void*, int, void*, void*);
+#define ADDED_FUNCTIONS()           \
 
-#define SUPER()                                     \
-    GO(krb5_get_init_creds_password, iFppppppipp_t) \
+#include "generated/wrappedkrb5types.h"
 
-typedef struct krb5_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} krb5_my_t;
-
-void* getKrb5My(library_t* lib)
-{
-    krb5_my_t* my = (krb5_my_t*)calloc(1, sizeof(krb5_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeKrb5My(void* lib)
-{
-    //krb5_my_t *my = (krb5_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -80,19 +58,14 @@ static void* find_krb5_prompter_Fct(void* fct)
 
 EXPORT int my_krb5_get_init_creds_password(x64emu_t* emu, void* context, void* creds, void* client, void* password, void* f, void* data, int delta, void* service, void* options)
 {
-    krb5_my_t* my = (krb5_my_t*)my_lib->priv.w.p2;
-
     return my->krb5_get_init_creds_password(context, creds, client, password, find_krb5_prompter_Fct(f), data, delta, service, options);
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getKrb5My(lib);    \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeKrb5My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedldapr.c b/src/wrapped/wrappedldapr.c
index 7bd046b4..4863e9cd 100755
--- a/src/wrapped/wrappedldapr.c
+++ b/src/wrapped/wrappedldapr.c
@@ -25,33 +25,12 @@ const char* ldaprName =
     ;
 #define ALTNAME "libldap-2.5.so.0"
 #define LIBNAME ldapr
-static library_t *my_lib = NULL;
-typedef int     (*iFpppppupp_t)      (void*, void*, void*, void* , void*, unsigned, void*, void*);
 
-#define SUPER()                                     \
-    GO(ldap_sasl_interactive_bind_s, iFpppppupp_t)  \
+#define ADDED_FUNCTIONS() \
 
-typedef struct ldapr_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} ldapr_my_t;
+#include "wrappedldaprtypes.h"
 
-void* getLdaprMy(library_t* lib)
-{
-    ldapr_my_t* my = (ldapr_my_t*)calloc(1, sizeof(ldapr_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeLdaprMy(void* lib)
-{
-    //ldapr_my_t *my = (ldapr_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -86,8 +65,6 @@ static void* find_LDAP_SASL_INTERACT_PROC_Fct(void* fct)
 
 EXPORT int my_ldap_sasl_interactive_bind_s(x64emu_t* emu, void* ld, void* dn, void* mechs, void* sctrls, void* cctrls, unsigned flags, void* f, void* defaults)
 {
-    ldapr_my_t* my = (ldapr_my_t*)my_lib->priv.w.p2;
-
     return my->ldap_sasl_interactive_bind_s(ld, dn, mechs, sctrls, cctrls, flags, find_LDAP_SASL_INTERACT_PROC_Fct(f), defaults);
 }
 
@@ -98,16 +75,11 @@ EXPORT int my_ldap_sasl_interactive_bind_s(x64emu_t* emu, void* ld, void* dn, vo
 #endif
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getLdaprMy(lib);                                           \
-    lib->priv.w.needed = 1;                                                     \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup(NEEDED_LIB);                             \
-    my_lib = lib;
+    getMy(lib);         \
+    setNeededLibs(&lib->priv.w, 1, NEEDED_LIB);
 
 #define CUSTOM_FINI \
-    freeLdaprMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibasound.c b/src/wrapped/wrappedlibasound.c
index 455d6e4f..54d55804 100755
--- a/src/wrapped/wrappedlibasound.c
+++ b/src/wrapped/wrappedlibasound.c
@@ -24,13 +24,6 @@ const char* libasoundName = "libasound.so.2";
 
 #include "generated/wrappedlibasoundtypes.h"
 
-typedef struct asound_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} asound_my_t;
-
 EXPORT uintptr_t my_snd_lib_error = 0;
 static void default_error_handler(const char *file, int line, const char *function, int err, const char *fmt, va_list ap)
 {
@@ -38,25 +31,13 @@ static void default_error_handler(const char *file, int line, const char *functi
     vprintf(fmt, ap);
 }
 
-void* getAsoundMy(library_t* lib)
-{
-    asound_my_t* my = (asound_my_t*)calloc(1, sizeof(asound_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    // setup custom error handler
+#define ADDED_INIT() \
     my_snd_lib_error = AddCheckBridge(my_context->system, vFpipipV, default_error_handler, 0, "ASoundCustomErrorHandler");
-    // all done
-    return my;
-}
-#undef SUPER
 
-void freeAsoundMy(void* lib)
-{
-    (void)lib;
-    // asound_my_t *my = (asound_my_t *)lib;
+#define ADDED_FINI() \
     my_snd_lib_error = 0;   // no removing of bridge
-}
+
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -90,15 +71,11 @@ static void* findAsyncFct(void* fct)
 
 EXPORT int my_snd_async_add_handler(x64emu_t *emu, void *handler, int fd, void* callback, void *private_data)
 {
-    asound_my_t* my = (asound_my_t*)emu->context->asound->priv.w.p2;
-
     return my->snd_async_add_handler(handler, fd, findAsyncFct(callback), private_data);
 }
 
 EXPORT int my_snd_async_add_pcm_handler(x64emu_t *emu, void *handler, void* pcm,  void* callback, void *private_data)
 {
-    asound_my_t* my = (asound_my_t*)emu->context->asound->priv.w.p2;
-
     return my->snd_async_add_pcm_handler(handler, pcm, findAsyncFct(callback), private_data);
 }
 
@@ -124,7 +101,6 @@ static void empty_error_handler(const char *file, int line, const char *function
 
 EXPORT int my_snd_lib_error_set_handler(x64emu_t* emu, void* handler)
 {
-    asound_my_t* my = (asound_my_t*)emu->context->asound->priv.w.p2;
     current_error_handler = handler;
     void *error_handler;
     uint8_t *code = (uint8_t *)handler;
@@ -163,11 +139,10 @@ EXPORT void* my_snd_dlsym(x64emu_t* emu, void* handle, void* name, void* version
 
 #define CUSTOM_INIT                     \
     box64->asound = lib;                \
-    lib->priv.w.p2 = getAsoundMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI                     \
     lib->context->asound = NULL;        \
-    freeAsoundMy(lib->priv.w.p2);       \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibc.c b/src/wrapped/wrappedlibc.c
index 6105f347..8fe3c13e 100755
--- a/src/wrapped/wrappedlibc.c
+++ b/src/wrapped/wrappedlibc.c
@@ -64,8 +64,6 @@
 #define LIBNAME libc
 const char* libcName = "libc.so.6";
 
-static library_t* my_lib = NULL;
-
 typedef int (*iFi_t)(int);
 typedef int (*iFL_t)(unsigned long);
 typedef void (*vFpp_t)(void*, void*);
@@ -95,27 +93,7 @@ typedef void* (*pFp_t)(void*);
     GO(_IO_file_stat, iFpp_t)
 
 
-typedef struct libc_my_s {
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libc_my_t;
-
-void* getLIBCMy(library_t* lib)
-{
-    libc_my_t* my = (libc_my_t*)calloc(1, sizeof(libc_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeLIBCMy(void* lib)
-{
-    (void)lib;
-    // empty for now
-}
+#include "wrappercallback.h"
 
 static int regs_abi[] = {_DI, _SI, _DX, _CX, _R8, _R9};
 void* getVargN(x64emu_t *emu, int n)
@@ -1112,7 +1090,6 @@ EXPORT int my_fstatat(x64emu_t *emu, int fd, const char* path, void* buf, int fl
 EXPORT int my__IO_file_stat(x64emu_t* emu, void* f, void* buf)
 {
     struct stat64 st;
-    libc_my_t *my = (libc_my_t *)emu->context->libclib->priv.w.p2;
     int r = my->_IO_file_stat(f, &st);
     UnalignStat64(&st, buf);
     return r;
@@ -2745,7 +2722,6 @@ EXPORT char my___libc_single_threaded = 0;
 
 #define CUSTOM_INIT         \
     box64->libclib = lib;   \
-    my_lib = lib;           \
     /*InitCpuModel();*/         \
     ctSetup();              \
     stSetup(box64);         \
@@ -2754,16 +2730,13 @@ EXPORT char my___libc_single_threaded = 0;
     my___progname_full = my_program_invocation_name = box64->argv[0];           \
     my___progname = my_program_invocation_short_name =                          \
         strrchr(box64->argv[0], '/') + 1;                                       \
-    lib->priv.w.p2 = getLIBCMy(lib);                                            \
-    lib->priv.w.needed = 3;                                                     \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("ld-linux-x86-64.so.2");                 \
-    lib->priv.w.neededlibs[1] = strdup("libpthread.so.0");                      \
-    lib->priv.w.neededlibs[2] = strdup("librt.so.1");
+    getMy(lib);                                                                 \
+    setNeededLibs(&lib->priv.w, 3,                                              \
+        "ld-linux-x86-64.so.2",                                                 \
+        "libpthread.so.0",                                                      \
+        "librt.so.1");
 
 #define CUSTOM_FINI \
-    freeLIBCMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibcups.c b/src/wrapped/wrappedlibcups.c
index be7ed99c..a99f0b45 100755
--- a/src/wrapped/wrappedlibcups.c
+++ b/src/wrapped/wrappedlibcups.c
@@ -21,39 +21,5 @@
 const char* libcupsName = "libcups.so.2";
 #define LIBNAME libcups
 
-#if 0
-#define SUPER()
-    GO(BZ2_bzCompressInit, iFpiii_t)
-
-typedef struct libcups_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libcups_my_t;
-
-void* getCupsMy(library_t* lib)
-{
-    libcups_my_t* my = (libcups_my_t*)calloc(1, sizeof(libcups_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeCupsMy(void* lib)
-{
-    libcups_my_t *my = (libcups_my_t *)lib;
-}
-
-#define CUSTOM_INIT \
-    lib->priv.w.p2 = getCupsMy(lib);
-
-#define CUSTOM_FINI \
-    freeCupsMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
-#endif
-
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibfuse.c b/src/wrapped/wrappedlibfuse.c
index aa07a595..41955970 100755
--- a/src/wrapped/wrappedlibfuse.c
+++ b/src/wrapped/wrappedlibfuse.c
@@ -15,12 +15,13 @@
 #include "myalign.h"
 #include "debug.h"
 
-static library_t *my_lib = NULL;
 const char* libfuseName = "libfuse.so.2";
 #define LIBNAME libfuse
 
 #include "generated/wrappedlibfusetypes.h"
 
+#include "wrappercallback.h"
+
 typedef struct fuse_lowlevel_ops_s {
     void (*init) (void *userdata, void *conn);
     void (*destroy) (void *userdata);
@@ -58,30 +59,6 @@ typedef struct fuse_lowlevel_ops_s {
     void (*bmap) (void* req, unsigned long ino, size_t blocksize, uint64_t idx);
 } fuse_lowlevel_ops_t;
 
-typedef struct libfuse_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libfuse_my_t;
-
-void* getFuseMy(library_t* lib)
-{
-    my_lib = lib;
-    libfuse_my_t* my = (libfuse_my_t*)calloc(1, sizeof(libfuse_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeFuseMy(void* lib)
-{
-    (void)lib;
-    //libfuse_my_t *my = (libfuse_my_t *)lib;
-}
-#undef SUPER
-
 #define SUPER() \
 GO(0)   \
 GO(1)   \
@@ -899,13 +876,11 @@ static void* find_bmap_Fct(void* fct)
 
 EXPORT int my_fuse_opt_parse(x64emu_t* emu, void* args, void* data, void* opts, void* f)
 {
-    libfuse_my_t *my = (libfuse_my_t*)my_lib->priv.w.p2;
     return my->fuse_opt_parse(args, data, opts, findfuse_opt_procFct(f));
 }
 
 EXPORT void* my_fuse_lowlevel_new(x64emu_t* emu, void* args, fuse_lowlevel_ops_t *o, size_t sz, void* data)
 {
-    libfuse_my_t *my = (libfuse_my_t*)my_lib->priv.w.p2;
     static fuse_lowlevel_ops_t o_;
     #define GO(A) o_.A = find_##A##_Fct(o->A); if(o_.A) printf_log(LOG_DEBUG, "fuse: %s is present\n", #A)
     GO(init);
@@ -947,10 +922,9 @@ EXPORT void* my_fuse_lowlevel_new(x64emu_t* emu, void* args, fuse_lowlevel_ops_t
 }
 
 #define CUSTOM_INIT                 \
-    lib->priv.w.p2 = getFuseMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI             \
-    freeFuseMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);
+    freeMy();
     
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibglu.c b/src/wrapped/wrappedlibglu.c
index 817b4e5c..2e08ec99 100755
--- a/src/wrapped/wrappedlibglu.c
+++ b/src/wrapped/wrappedlibglu.c
@@ -23,28 +23,7 @@ const char* libgluName = "libGLU.so.1";
 
 #include "generated/wrappedlibglutypes.h"
 
-typedef struct libglu_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libglu_my_t;
-
-void* getGLUMy(library_t* lib)
-{
-    libglu_my_t* my = (libglu_my_t*)calloc(1, sizeof(libglu_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeGLUMy(void* lib)
-{
-    (void)lib;
-    //libglu_my_t *my = (libglu_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -134,13 +113,11 @@ static void* findglu_callback5Fct(void* fct)
 void EXPORT my_gluQuadricCallback(x64emu_t* emu, void* a, int32_t b, void* cb)
 {
     (void)emu;
-    libglu_my_t *my = (libglu_my_t*)emu->context->libglu->priv.w.p2;
     my->gluQuadricCallback(a, b, findglu_callbackFct(cb));
 }
 void EXPORT my_gluTessCallback(x64emu_t* emu, void* a, int32_t b, void* cb)
 {
     (void)emu;
-    libglu_my_t *my = (libglu_my_t*)emu->context->libglu->priv.w.p2;
     if(b==GLU_TESS_COMBINE)
         my->gluTessCallback(a, b, findglu_callback4Fct(cb));
     else if(b==GLU_TESS_COMBINE_DATA)
@@ -151,20 +128,15 @@ void EXPORT my_gluTessCallback(x64emu_t* emu, void* a, int32_t b, void* cb)
 void EXPORT my_gluNurbsCallback(x64emu_t* emu, void* a, int32_t b, void* cb)
 {
     (void)emu;
-    libglu_my_t *my = (libglu_my_t*)emu->context->libglu->priv.w.p2;
     my->gluNurbsCallback(a, b, findglu_callbackFct(cb));
 }
 
 #define CUSTOM_INIT                     \
     box64->libglu = lib;                \
-    lib->priv.w.p2 = getGLUMy(lib);     \
-    lib->priv.w.needed = 1;             \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libGL.so.1"); \
+    getMy(lib);                         \
+    setNeededLibs(&lib->priv.w, 1, "libGL.so.1");
 
 #define CUSTOM_FINI             \
-    freeGLUMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);
-
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibice.c b/src/wrapped/wrappedlibice.c
index 32334441..3a3ff742 100755
--- a/src/wrapped/wrappedlibice.c
+++ b/src/wrapped/wrappedlibice.c
@@ -21,39 +21,5 @@
 const char* libiceName = "libICE.so.6";
 #define LIBNAME libice
 
-#if 0
-#define SUPER()
-    GO(BZ2_bzCompressInit, iFpiii_t)
-
-typedef struct libice_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libice_my_t;
-
-void* getICEMy(library_t* lib)
-{
-    libice_my_t* my = (libice_my_t*)calloc(1, sizeof(libice_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeICEMy(void* lib)
-{
-    libice_my_t *my = (libice_my_t *)lib;
-}
-
-#define CUSTOM_INIT \
-    lib->priv.w.p2 = getICEMy(lib);
-
-#define CUSTOM_FINI \
-    freeICEMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
-#endif
-
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibncurses.c b/src/wrapped/wrappedlibncurses.c
index 901a5e0e..f9d49767 100755
--- a/src/wrapped/wrappedlibncurses.c
+++ b/src/wrapped/wrappedlibncurses.c
@@ -22,39 +22,15 @@
 const char* libncursesName = "libncurses.so.5";
 #define LIBNAME libncurses
 
-static library_t* my_lib = NULL;
-
 // this is a simple copy of libncursesw wrapper. TODO: check if ok
 
 #define ADDED_FUNCTIONS() GO(stdscr, void*)
 #include "generated/wrappedlibncursestypes.h"
 
-typedef struct libncurses_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libncurses_my_t;
-
-void* getNCursesMy(library_t* lib)
-{
-    libncurses_my_t* my = (libncurses_my_t*)calloc(1, sizeof(libncurses_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeNCursesMy(void* lib)
-{
-    //libncurses_my_t *my = (libncurses_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 EXPORT int my_mvwprintw(x64emu_t* emu, void* win, int32_t y, int32_t x, void* fmt, void* b)
 {
-    libncurses_my_t *my = (libncurses_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 4);
     PREPARE_VALIST;
@@ -68,8 +44,6 @@ EXPORT int my_mvwprintw(x64emu_t* emu, void* win, int32_t y, int32_t x, void* fm
 
 EXPORT int my_printw(x64emu_t* emu, void* fmt, void* b)
 {
-    libncurses_my_t *my = (libncurses_my_t*)my_lib->priv.w.p2;
-
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->vwprintw(my->stdscr, fmt, VARARGS);
@@ -77,8 +51,6 @@ EXPORT int my_printw(x64emu_t* emu, void* fmt, void* b)
 
 EXPORT int my_vwprintw(x64emu_t* emu, void* p, void* fmt, x64_va_list_t b)
 {
-    libncurses_my_t *my = (libncurses_my_t*)my_lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -90,8 +62,6 @@ EXPORT int my_vwprintw(x64emu_t* emu, void* p, void* fmt, x64_va_list_t b)
 
 EXPORT int my_mvprintw(x64emu_t* emu, int x, int y, void* fmt, void* b)
 {
-    libncurses_my_t *my = (libncurses_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
@@ -105,22 +75,16 @@ EXPORT int my_mvprintw(x64emu_t* emu, int x, int y, void* fmt, void* b)
 
 EXPORT void* my_initscr()
 {
-    libncurses_my_t *my = (libncurses_my_t*)my_lib->priv.w.p2;
     void* ret = my->initscr();
     my_checkGlobalTInfo();
     return ret;
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getNCursesMy(lib); \
-    my_lib = lib; \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libtinfo.so.5");
+    getMy(lib); \
+    setNeededLibs(&lib->priv.w,  1, "libtinfo.so.5");
 
 #define CUSTOM_FINI \
-    freeNCursesMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2); \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibncurses6.c b/src/wrapped/wrappedlibncurses6.c
index 164d9ceb..a41dacac 100755
--- a/src/wrapped/wrappedlibncurses6.c
+++ b/src/wrapped/wrappedlibncurses6.c
@@ -22,39 +22,15 @@
 const char* libncurses6Name = "libncurses.so.6";
 #define LIBNAME libncurses6
 
-static library_t* my_lib = NULL;
-
 // this is a simple copy of libncursesw wrapper. TODO: check if ok
 
 #define ADDED_FUNCTIONS() GO(stdscr, void*)
 #include "generated/wrappedlibncurses6types.h"
 
-typedef struct libncurses6_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libncurses6_my_t;
-
-void* getNCurses6My(library_t* lib)
-{
-    libncurses6_my_t* my = (libncurses6_my_t*)calloc(1, sizeof(libncurses6_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeNCurses6My(void* lib)
-{
-    //libncurses6_my_t *my = (libncurses6_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 EXPORT int my6_mvwprintw(x64emu_t* emu, void* win, int32_t y, int32_t x, void* fmt, void* b)
 {
-    libncurses6_my_t *my = (libncurses6_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 4);
     PREPARE_VALIST;
@@ -68,8 +44,6 @@ EXPORT int my6_mvwprintw(x64emu_t* emu, void* win, int32_t y, int32_t x, void* f
 
 EXPORT int my6_printw(x64emu_t* emu, void* fmt, void* b)
 {
-    libncurses6_my_t *my = (libncurses6_my_t*)my_lib->priv.w.p2;
-
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->vwprintw(my->stdscr, fmt, VARARGS);
@@ -77,8 +51,6 @@ EXPORT int my6_printw(x64emu_t* emu, void* fmt, void* b)
 
 EXPORT int my6_vwprintw(x64emu_t* emu, void* p, void* fmt, x64_va_list_t b)
 {
-    libncurses6_my_t *my = (libncurses6_my_t*)my_lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -90,8 +62,6 @@ EXPORT int my6_vwprintw(x64emu_t* emu, void* p, void* fmt, x64_va_list_t b)
 
 EXPORT int my6_mvprintw(x64emu_t* emu, int x, int y, void* fmt, void* b)
 {
-    libncurses6_my_t *my = (libncurses6_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
@@ -105,23 +75,17 @@ EXPORT int my6_mvprintw(x64emu_t* emu, int x, int y, void* fmt, void* b)
 
 EXPORT void* my6_initscr()
 {
-    libncurses6_my_t *my = (libncurses6_my_t*)my_lib->priv.w.p2;
     void* ret = my->initscr();
     my_checkGlobalTInfo();
     return ret;
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getNCurses6My(lib);    \
-    my_lib = lib;                           \
-    lib->altmy = strdup("my6_");            \
-    lib->priv.w.needed = 1;                 \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libtinfo.so.6");
+    getMy(lib);     \
+    SETALT(my6_);   \
+    setNeededLibs(&lib->priv.w, 1, "libtinfo.so.6");
 
 #define CUSTOM_FINI \
-    freeNCurses6My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);           \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibncursesw.c b/src/wrapped/wrappedlibncursesw.c
index 1b110f1c..51ada784 100755
--- a/src/wrapped/wrappedlibncursesw.c
+++ b/src/wrapped/wrappedlibncursesw.c
@@ -22,37 +22,13 @@
 const char* libncurseswName = "libncursesw.so.5";
 #define LIBNAME libncursesw
 
-static library_t* my_lib = NULL;
-
 #define ADDED_FUNCTIONS() GO(stdscr, void*)
 #include "generated/wrappedlibncurseswtypes.h"
 
-typedef struct libncursesw_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libncursesw_my_t;
-
-void* getNCurseswMy(library_t* lib)
-{
-    libncursesw_my_t* my = (libncursesw_my_t*)calloc(1, sizeof(libncursesw_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeNCurseswMy(void* lib)
-{
-    //libncursesw_my_t *my = (libncursesw_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 EXPORT int myw_mvwprintw(x64emu_t* emu, void* win, int32_t y, int32_t x, void* fmt, void* b)
 {
-    libncursesw_my_t *my = (libncursesw_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 4);
     PREPARE_VALIST;
@@ -66,8 +42,6 @@ EXPORT int myw_mvwprintw(x64emu_t* emu, void* win, int32_t y, int32_t x, void* f
 
 EXPORT int myw_printw(x64emu_t* emu, void* fmt, void* b)
 {
-    libncursesw_my_t *my = (libncursesw_my_t*)my_lib->priv.w.p2;
-
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->vwprintw(my->stdscr, fmt, VARARGS);
@@ -75,8 +49,6 @@ EXPORT int myw_printw(x64emu_t* emu, void* fmt, void* b)
 
 EXPORT int myw_vwprintw(x64emu_t* emu, void* p, void* fmt, x64_va_list_t b)
 {
-    libncursesw_my_t *my = (libncursesw_my_t*)my_lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -88,8 +60,6 @@ EXPORT int myw_vwprintw(x64emu_t* emu, void* p, void* fmt, x64_va_list_t b)
 
 EXPORT int myw_mvprintw(x64emu_t* emu, int x, int y, void* fmt, void* b)
 {
-    libncursesw_my_t *my = (libncursesw_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
@@ -103,23 +73,17 @@ EXPORT int myw_mvprintw(x64emu_t* emu, int x, int y, void* fmt, void* b)
 
 EXPORT void* myw_initscr()
 {
-    libncursesw_my_t *my = (libncursesw_my_t*)my_lib->priv.w.p2;
     void* ret = my->initscr();
     my_checkGlobalTInfo();
     return ret;
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getNCurseswMy(lib); \
-    my_lib = lib;   \
-    lib->altmy = strdup("myw_"); \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libtinfo.so.5");
+    getMy(lib);     \
+    SETALT(myw_);   \
+    setNeededLibs(&lib->priv.w, 1, "libtinfo.so.5");
 
 #define CUSTOM_FINI \
-    freeNCurseswMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);           \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibncursesw6.c b/src/wrapped/wrappedlibncursesw6.c
index 94bec66d..e6431777 100755
--- a/src/wrapped/wrappedlibncursesw6.c
+++ b/src/wrapped/wrappedlibncursesw6.c
@@ -22,37 +22,13 @@
 const char* libncursesw6Name = "libncursesw.so.6";
 #define LIBNAME libncursesw6
 
-static library_t* my_lib = NULL;
-
 #define ADDED_FUNCTIONS() GO(stdscr, void*)
 #include "generated/wrappedlibncurseswtypes.h"
 
-typedef struct libncursesw6_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libncursesw6_my_t;
-
-void* getNCursesw6My(library_t* lib)
-{
-    libncursesw6_my_t* my = (libncursesw6_my_t*)calloc(1, sizeof(libncursesw6_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeNCursesw6My(void* lib)
-{
-    //libncursesw6_my_t *my = (libncursesw6_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 EXPORT int myw6_mvwprintw(x64emu_t* emu, void* win, int32_t y, int32_t x, void* fmt, void* b)
 {
-    libncursesw6_my_t *my = (libncursesw6_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 4);
     PREPARE_VALIST;
@@ -66,8 +42,6 @@ EXPORT int myw6_mvwprintw(x64emu_t* emu, void* win, int32_t y, int32_t x, void*
 
 EXPORT int myw6_printw(x64emu_t* emu, void* fmt, void* b)
 {
-    libncursesw6_my_t *my = (libncursesw6_my_t*)my_lib->priv.w.p2;
-
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
     PREPARE_VALIST;
     return my->vwprintw(my->stdscr, fmt, VARARGS);
@@ -75,8 +49,6 @@ EXPORT int myw6_printw(x64emu_t* emu, void* fmt, void* b)
 
 EXPORT int myw6_vwprintw(x64emu_t* emu, void* p, void* fmt, x64_va_list_t b)
 {
-    libncursesw6_my_t *my = (libncursesw6_my_t*)my_lib->priv.w.p2;
-
     #ifdef CONVERT_VALIST
     CONVERT_VALIST(b);
     #else
@@ -88,8 +60,6 @@ EXPORT int myw6_vwprintw(x64emu_t* emu, void* p, void* fmt, x64_va_list_t b)
 
 EXPORT int myw6_mvprintw(x64emu_t* emu, int x, int y, void* fmt, void* b)
 {
-    libncursesw6_my_t *my = (libncursesw6_my_t*)my_lib->priv.w.p2;
-
     char* buf = NULL;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
@@ -103,23 +73,17 @@ EXPORT int myw6_mvprintw(x64emu_t* emu, int x, int y, void* fmt, void* b)
 
 EXPORT void* myw6_initscr()
 {
-    libncursesw6_my_t *my = (libncursesw6_my_t*)my_lib->priv.w.p2;
     void* ret = my->initscr();
     my_checkGlobalTInfo();
     return ret;
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getNCursesw6My(lib); \
-    my_lib = lib;   \
-    lib->altmy = strdup("myw6_"); \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libtinfo.so.6");
+    getMy(lib);     \
+    SETALT(myw6_);  \
+    setNeededLibs(&lib->priv.w, 1, "libtinfo.so.6");
 
 #define CUSTOM_FINI \
-    freeNCursesw6My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);           \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibsm.c b/src/wrapped/wrappedlibsm.c
index ef9c81bc..daf095b7 100755
--- a/src/wrapped/wrappedlibsm.c
+++ b/src/wrapped/wrappedlibsm.c
@@ -23,28 +23,7 @@ const char* libsmName = "libSM.so.6";
 
 #include "generated/wrappedlibsmtypes.h"
 
-typedef struct libsm_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libsm_my_t;
-
-void* getSMMy(library_t* lib)
-{
-    libsm_my_t* my = (libsm_my_t*)calloc(1, sizeof(libsm_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeSMMy(void* lib)
-{
-    (void)lib;
-    //libsm_my_t *my = (libsm_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 typedef struct my_SmcCallbacks_s {
     struct {
@@ -100,7 +79,6 @@ static void my_save_complete(void* smcConn, void* clientData)
 EXPORT void* my_SmcOpenConnection(x64emu_t* emu, void* networkIdsList, void* context, int major, int minor, unsigned long mask, my_SmcCallbacks_t* cb, void* previousId, void* clientIdRet, int errorLength, void* errorRet)
 {
     (void)emu;
-    libsm_my_t* my = (libsm_my_t*)GetLibInternal(libsmName)->priv.w.p2;
     my_SmcCallbacks_t nat = {0};
     #define GO(A, B) if(mask&A) {my_##B##_fct = (uintptr_t)cb->B.callback; nat.B.callback = my_##B; nat.B.client_data=cb->B.client_data;}
     GO(SmcSaveYourselfProcMask, save_yourself)
@@ -148,22 +126,19 @@ static void* findRequestFct(void* fct)
 EXPORT int my_SmcInteractRequest(x64emu_t* emu, void* smcConn, int f, void* cb, void* data)
 {
     (void)emu;
-    libsm_my_t* my = (libsm_my_t*)GetLibInternal(libsmName)->priv.w.p2;
     return my->SmcInteractRequest(smcConn, f, findRequestFct(cb), data);
 }
 
 EXPORT int my_SmcRequestSaveYourselfPhase2(x64emu_t* emu, void* smcConn, void* cb, void* data)
 {
     (void)emu;
-    libsm_my_t* my = (libsm_my_t*)GetLibInternal(libsmName)->priv.w.p2;
     return my->SmcRequestSaveYourselfPhase2(smcConn, findRequestFct(cb), data);
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getSMMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeSMMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibsndfile.c b/src/wrapped/wrappedlibsndfile.c
index 2c4310d8..37660663 100755
--- a/src/wrapped/wrappedlibsndfile.c
+++ b/src/wrapped/wrappedlibsndfile.c
@@ -20,35 +20,11 @@
 const char* libsndfileName = "libsndfile.so.1";
 #define LIBNAME libsndfile
 
-typedef int   (*iFp_t)(void*);
-typedef void* (*pFpipp_t)(void*, int32_t, void*, void*);
+#define ADDED_FUNCTIONS()           \
 
-#define SUPER() \
-    GO(sf_open_virtual, pFpipp_t)    \
-    GO(sf_close, iFp_t)
-
-typedef struct sndfile_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} sndfile_my_t;
+#include "generated/wrappedlibsndfiletypes.h"
 
-void* getSndfileMy(library_t* lib)
-{
-    sndfile_my_t* my = (sndfile_my_t*)calloc(1, sizeof(sndfile_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-
-    return my;
-}
-#undef SUPER
-
-void freeSndfileMy(void* lib)
-{
-    //sndfile_my_t *my = (sndfile_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -184,9 +160,6 @@ typedef struct my_sfvirtual_io_s
 
 EXPORT void* my_sf_open_virtual(x64emu_t* emu, my_sfvirtual_io_t* sfvirtual, int mode, void* sfinfo, void* data)
 {
-    library_t * lib = GetLibInternal(libsndfileName);
-    sndfile_my_t *my = (sndfile_my_t*)lib->priv.w.p2;
-
     my_sfvirtual_io_t native = {0};
     native.get_filelen = find_sf_vio_get_filelen_Fct(sfvirtual->get_filelen);
     native.seek = find_sf_vio_seek_Fct(sfvirtual->seek);
@@ -199,18 +172,14 @@ EXPORT void* my_sf_open_virtual(x64emu_t* emu, my_sfvirtual_io_t* sfvirtual, int
 
 EXPORT int my_sf_close(x64emu_t* emu, void* sf)
 {
-    library_t * lib = GetLibInternal(libsndfileName);
-    sndfile_my_t *my = (sndfile_my_t*)lib->priv.w.p2;
-
     return my->sf_close(sf);
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getSndfileMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeSndfileMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibssl.c b/src/wrapped/wrappedlibssl.c
index 8a9fd7a0..380394fa 100755
--- a/src/wrapped/wrappedlibssl.c
+++ b/src/wrapped/wrappedlibssl.c
@@ -22,32 +22,9 @@ const char* libsslName = "libssl.so.1.0.0";
 #define ALTNAME "libssl.so.1.0.2"
 #define ALTNAME2 "libssl.so.1.1"
 
-static library_t* my_lib = NULL;
-
 #include "generated/wrappedlibssltypes.h"
 
-typedef struct libssl_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libssl_my_t;
-
-void* getSllMy(library_t* lib)
-{
-    libssl_my_t* my = (libssl_my_t*)calloc(1, sizeof(libssl_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeSllMy(void* lib)
-{
-    (void)lib;
-    //libssl_my_t *my = (libssl_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 // utility functions
 #define SUPER() \
@@ -255,66 +232,55 @@ static void* find_proto_select_Fct(void* fct)
 EXPORT void my_SSL_CTX_set_default_passwd_cb(x64emu_t* emu, void* ctx, void* cb)
 {
     (void)emu;
-    libssl_my_t* my = (libssl_my_t*)my_lib->priv.w.p2;
     my->SSL_CTX_set_default_passwd_cb(ctx, find_pem_passwd_cb_Fct(cb));
 }
 
 EXPORT long my_SSL_CTX_callback_ctrl(x64emu_t* emu, void* ctx, int cmd, void* f)
 {
     (void)emu;
-    libssl_my_t* my = (libssl_my_t*)my_lib->priv.w.p2;
     return my->SSL_CTX_callback_ctrl(ctx, cmd, find_anonymous_Fct(f));
 }
 
 EXPORT long my_SSL_callback_ctrl(x64emu_t* emu, void* ctx, int cmd, void* f)
 {
     (void)emu;
-    libssl_my_t* my = (libssl_my_t*)my_lib->priv.w.p2;
     return my->SSL_callback_ctrl(ctx, cmd, find_anonymous_Fct(f));
 }
 
 EXPORT void my_SSL_CTX_set_verify(x64emu_t* emu, void* ctx, int mode, void* f)
 {
     (void)emu;
-    libssl_my_t* my = (libssl_my_t*)my_lib->priv.w.p2;
     my->SSL_CTX_set_verify(ctx, mode, find_verify_Fct(f));
 }
 
 EXPORT void my_SSL_set_verify(x64emu_t* emu, void* ctx, int mode, void* f)
 {
     (void)emu;
-    libssl_my_t* my = (libssl_my_t*)my_lib->priv.w.p2;
     my->SSL_set_verify(ctx, mode, find_verify_Fct(f));
 }
 
 EXPORT void my_SSL_get_ex_new_index(x64emu_t* emu, long argl, void* argp, void* new_func, void* dup_func, void* free_func)
 {
     (void)emu;
-    libssl_my_t* my = (libssl_my_t*)my_lib->priv.w.p2;
     my->SSL_get_ex_new_index(argl, argp, find_ex_new_Fct(new_func), find_ex_dup_Fct(dup_func), find_ex_free_Fct(free_func));
 }
 
 EXPORT void my_SSL_set_psk_client_callback(x64emu_t* emu, void* ctx, void* cb)
 {
     (void)emu;
-    libssl_my_t* my = (libssl_my_t*)my_lib->priv.w.p2;
     my->SSL_set_psk_client_callback(ctx, find_client_cb_Fct(cb));
 }
 
 EXPORT void my_SSL_CTX_set_next_proto_select_cb(x64emu_t* emu, void* ctx, void* cb, void* arg)
 {
     (void)emu;
-    libssl_my_t* my = (libssl_my_t*)my_lib->priv.w.p2;
     my->SSL_CTX_set_next_proto_select_cb(ctx, find_proto_select_Fct(cb), arg);
 }
 
 #define CUSTOM_INIT \
-    my_lib = lib;   \
-    lib->priv.w.p2 = getSllMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    my_lib = NULL;              \
-    freeSllMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibtinfo.c b/src/wrapped/wrappedlibtinfo.c
index 9d10d0b1..6e15e498 100755
--- a/src/wrapped/wrappedlibtinfo.c
+++ b/src/wrapped/wrappedlibtinfo.c
@@ -21,31 +21,9 @@
 const char* libtinfoName = "libtinfo.so.5";
 #define LIBNAME libtinfo
 
-static library_t* my_lib = NULL;
-
 #include "generated/wrappedlibtinfotypes.h"
 
-typedef struct libtinfo_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libtinfo_my_t;
-
-void* getTinfoMy(library_t* lib)
-{
-    libtinfo_my_t* my = (libtinfo_my_t*)calloc(1, sizeof(libtinfo_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeTinfoMy(void* lib)
-{
-    //libtinfo_my_t *my = (libtinfo_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 // utility functions
 #define SUPER() \
@@ -83,18 +61,13 @@ static void* find_putc_Fct(void* fct)
 
 EXPORT int my_tputs(x64emu_t* emu, void* str, int affcnt, void* f)
 {
-    libtinfo_my_t* my = (libtinfo_my_t*)my_lib->priv.w.p2;
-
     return my->tputs(str, affcnt, find_putc_Fct(f));
 }
 
 #define CUSTOM_INIT \
-    my_lib = lib;   \
-    lib->priv.w.p2 = getTinfoMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    my_lib = NULL;              \
-    freeTinfoMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibtinfo6.c b/src/wrapped/wrappedlibtinfo6.c
index af7254ff..9b1fc0ac 100755
--- a/src/wrapped/wrappedlibtinfo6.c
+++ b/src/wrapped/wrappedlibtinfo6.c
@@ -21,31 +21,9 @@
 const char* libtinfo6Name = "libtinfo.so.6";
 #define LIBNAME libtinfo6
 
-static library_t* my_lib = NULL;
-
 #include "generated/wrappedlibtinfo6types.h"
 
-typedef struct libtinfo6_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libtinfo6_my_t;
-
-void* getTinfo6My(library_t* lib)
-{
-    libtinfo6_my_t* my = (libtinfo6_my_t*)calloc(1, sizeof(libtinfo6_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeTinfo6My(void* lib)
-{
-    //libtinfo6_my_t *my = (libtinfo6_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 // utility functions
 #define SUPER() \
@@ -83,19 +61,14 @@ static void* find_putc_Fct(void* fct)
 
 EXPORT int my6_tputs(x64emu_t* emu, void* str, int affcnt, void* f)
 {
-    libtinfo6_my_t* my = (libtinfo6_my_t*)my_lib->priv.w.p2;
-
     return my->tputs(str, affcnt, find_putc_Fct(f));
 }
 
 #define CUSTOM_INIT \
-    my_lib = lib;   \
-    lib->altmy = strdup("my6_"); \
-    lib->priv.w.p2 = getTinfo6My(lib);
+    SETALT(my6_); \
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    my_lib = NULL;              \
-    freeTinfo6My(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibusb1.c b/src/wrapped/wrappedlibusb1.c
index 9d4b21d4..31d0867b 100755
--- a/src/wrapped/wrappedlibusb1.c
+++ b/src/wrapped/wrappedlibusb1.c
@@ -21,40 +21,11 @@
 const char* libusb1Name = "libusb-1.0.so.0";
 #define LIBNAME libusb1
 
-typedef void*   (*pFi_t)            (int);
-typedef int     (*iFp_t)            (void*);
-typedef void    (*vFpu_t)           (void*, uint32_t);
-typedef int     (*iFpiiiiippp_t)    (void*, int, int, int, int, int, void*, void*, void*);
+#define ADDED_FUNCTIONS()           \
 
-static library_t* my_lib = NULL;
+#include "generated/wrappedlibusb1types.h"
 
-#define SUPER() \
-    GO(libusb_hotplug_register_callback, iFpiiiiippp_t) \
-    GO(libusb_alloc_transfer, pFi_t)                    \
-    GO(libusb_submit_transfer, iFp_t)                   \
-    GO(libusb_cancel_transfer, iFp_t)                   \
-
-typedef struct libusb1_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libusb1_my_t;
-
-void* getUsb1My(library_t* lib)
-{
-    libusb1_my_t* my = (libusb1_my_t*)calloc(1, sizeof(libusb1_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeUsb1My(void* lib)
-{
-//    libusb1_my_t *my = (libusb1_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -131,8 +102,6 @@ static void* reverse_transfert_Fct(void* fct)
 
 EXPORT int my_libusb_hotplug_register_callback(x64emu_t* emu, void* ctx, int event, int flags, int vendor, int product, int dev_class, void* f, void* data, void* handle)
 {
-    libusb1_my_t *my = (libusb1_my_t*)my_lib->priv.w.p2;
-
     return my->libusb_hotplug_register_callback(ctx, event, flags, vendor, product, dev_class, findhotplugFct(f), data, handle);
 }
 
@@ -160,8 +129,6 @@ typedef struct my_libusb_transfer_s {
 
 EXPORT void* my_libusb_alloc_transfer(x64emu_t* emu, int num)
 {
-    libusb1_my_t *my = (libusb1_my_t*)my_lib->priv.w.p2;
-
     my_libusb_transfer_t* ret = (my_libusb_transfer_t*)my->libusb_alloc_transfer(num);
     if(ret)
         ret->callback = reverse_transfert_Fct(ret->callback);
@@ -170,27 +137,21 @@ EXPORT void* my_libusb_alloc_transfer(x64emu_t* emu, int num)
 
 EXPORT int my_libusb_submit_transfer(x64emu_t* emu, my_libusb_transfer_t* t)
 {
-    libusb1_my_t *my = (libusb1_my_t*)my_lib->priv.w.p2;
-    
     t->callback = findtransfertFct(t->callback);
     return my->libusb_submit_transfer(t); // don't put back callback, it's unknown if it's safe
 } 
 
 EXPORT int my_libusb_cancel_transfer(x64emu_t* emu, my_libusb_transfer_t* t)
 {
-    libusb1_my_t *my = (libusb1_my_t*)my_lib->priv.w.p2;
-    
     t->callback = findtransfertFct(t->callback);
     return my->libusb_cancel_transfer(t);
 }
 
 #define CUSTOM_INIT \
-    my_lib = lib;   \
-    lib->priv.w.p2 = getUsb1My(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeUsb1My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibvorbis.c b/src/wrapped/wrappedlibvorbis.c
index c433be2b..d9018689 100755
--- a/src/wrapped/wrappedlibvorbis.c
+++ b/src/wrapped/wrappedlibvorbis.c
@@ -21,32 +21,10 @@
 const char* libvorbisName = "libvorbis.so.0";
 #define LIBNAME libvorbis
 
-
-typedef struct vorbis_my_s {
-} vorbis_my_t;
-
-void* getVorbisMy(library_t* lib)
-{
-    vorbis_my_t* my = (vorbis_my_t*)calloc(1, sizeof(vorbis_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    (void)lib; // So many wrapped functions here too
-    #undef GO
-    return my;
-}
-
-void freeVorbisMy(void* lib)
-{
-    (void)lib;
-    //vorbis_my_t *my = (vorbis_my_t *)lib;
-}
-
 #define CUSTOM_INIT \
-    box64->vorbis = lib; \
-    lib->priv.w.p2 = getVorbisMy(lib);
+    box64->vorbis = lib;
 
 #define CUSTOM_FINI \
-    freeVorbisMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2); \
     lib->context->vorbis = NULL;
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibx11.c b/src/wrapped/wrappedlibx11.c
index 32f3ed26..9d8fd445 100755
--- a/src/wrapped/wrappedlibx11.c
+++ b/src/wrapped/wrappedlibx11.c
@@ -94,28 +94,7 @@ typedef void* (*pFpiiuu_t)(void*, int32_t, int32_t, uint32_t, uint32_t);
 
 #include "generated/wrappedlibx11types.h"
 
-typedef struct x11_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} x11_my_t;
-
-void* getX11My(library_t* lib)
-{
-    x11_my_t* my = (x11_my_t*)calloc(1, sizeof(x11_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeX11My(void* lib)
-{
-    (void)lib;
-    // x11_my_t *my = (x11_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -641,8 +620,6 @@ if (new_va[i] && strcmp((char*)new_va[i], A) == 0) {    \
 }
 
 EXPORT void* my_XVaCreateNestedList(x64emu_t* emu, int unused, uintptr_t* va) {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     int n = 0;
     while (getVArgs(emu, 1, va, n)) n+=2 ;
     void** new_va = malloc(sizeof(void*) * n);
@@ -662,8 +639,6 @@ EXPORT void* my_XVaCreateNestedList(x64emu_t* emu, int unused, uintptr_t* va) {
 }
 
 EXPORT void* my_XCreateIC(x64emu_t* emu, void* xim, uintptr_t* va) {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     int n = 0;
     while (getVArgs(emu, 1, va, n)) n+=2;
     void** new_va = malloc(sizeof(void*) * n);
@@ -683,8 +658,6 @@ EXPORT void* my_XCreateIC(x64emu_t* emu, void* xim, uintptr_t* va) {
 }
 
 EXPORT void* my_XSetICValues(x64emu_t* emu, void* xic, uintptr_t* va) {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     int n = 0;
     while (getVArgs(emu, 1, va, n)) n+=2;
     void** new_va = malloc(sizeof(void*) * n);
@@ -705,8 +678,6 @@ EXPORT void* my_XSetICValues(x64emu_t* emu, void* xic, uintptr_t* va) {
 #undef GO
 
 EXPORT void* my_XSetIMValues(x64emu_t* emu, void* xim, uintptr_t* va) {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     int n = 0;
     while (getVArgs(emu, 1, va, n)) n+=2;
     void** new_va = malloc(sizeof(void*) * n);
@@ -739,56 +710,42 @@ EXPORT void* my_XSetIMValues(x64emu_t* emu, void* xim, uintptr_t* va) {
 
 EXPORT void* my_XSetErrorHandler(x64emu_t* emu, XErrorHandler handler)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     void* ret = my->XSetErrorHandler(finderror_handlerFct(handler));
-    return reverse_error_handlerFct(lib, ret);
+    return reverse_error_handlerFct(my_lib, ret);
 }
 
 EXPORT void* my_XSetIOErrorHandler(x64emu_t* emu, XIOErrorHandler handler)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     void* ret = my->XSetIOErrorHandler(findioerror_handlerFct(handler));
-    return reverse_ioerror_handlerFct(lib, ret);
+    return reverse_ioerror_handlerFct(my_lib, ret);
 }
 
 EXPORT void* my_XESetError(x64emu_t* emu, void* display, int32_t extension, void* handler)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     void* ret = my->XESetError(display, extension, findexterror_handlerFct(handler));
-    return reverse_exterror_handlerFct(lib, ret);
+    return reverse_exterror_handlerFct(my_lib, ret);
 }
 
 EXPORT void* my_XESetCloseDisplay(x64emu_t* emu, void* display, int32_t extension, void* handler)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     void* ret = my->XESetCloseDisplay(display, extension, findclose_displayFct(handler));
-    return reverse_close_displayFct(lib, ret);
+    return reverse_close_displayFct(my_lib, ret);
 }
 
 EXPORT int32_t my_XIfEvent(x64emu_t* emu, void* d,void* ev, EventHandler h, void* arg)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     int32_t ret = my->XIfEvent(d, ev, findxifeventFct(h), arg);
     return ret;
 }
 
 EXPORT int32_t my_XCheckIfEvent(x64emu_t* emu, void* d,void* ev, EventHandler h, void* arg)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     int32_t ret = my->XCheckIfEvent(d, ev, findxifeventFct(h), arg);
     return ret;
 }
 
 EXPORT int32_t my_XPeekIfEvent(x64emu_t* emu, void* d,void* ev, EventHandler h, void* arg)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     int32_t ret = my->XPeekIfEvent(d, ev, findxifeventFct(h), arg);
     return ret;
 }
@@ -848,8 +805,6 @@ void sub_image_wrapper(x64emu_t *emu, uintptr_t fnc)
 EXPORT void* my_XCreateImage(x64emu_t* emu, void* disp, void* vis, uint32_t depth, int32_t fmt, int32_t off
                     , void* data, uint32_t w, uint32_t h, int32_t pad, int32_t bpl)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
 
     XImage *img = my->XCreateImage(disp, vis, depth, fmt, off, data, w, h, pad, bpl);
     if(!img)
@@ -861,8 +816,6 @@ EXPORT void* my_XCreateImage(x64emu_t* emu, void* disp, void* vis, uint32_t dept
 
 EXPORT int32_t my_XInitImage(x64emu_t* emu, void* img)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
 
     int ret = my->XInitImage(img);
     // bridge all access functions...
@@ -873,8 +826,6 @@ EXPORT int32_t my_XInitImage(x64emu_t* emu, void* img)
 EXPORT void* my_XGetImage(x64emu_t* emu, void* disp, void* drawable, int32_t x, int32_t y
                     , uint32_t w, uint32_t h, uint32_t plane, int32_t fmt)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
 
     XImage *img = my->XGetImage(disp, drawable, x, y, w, h, plane, fmt);
     if(!img)
@@ -888,8 +839,6 @@ EXPORT int32_t my_XPutImage(x64emu_t* emu, void* disp, void* drawable, void* gc,
                     , int32_t src_x, int32_t src_y, int32_t dst_x, int32_t dst_y
                     , uint32_t w, uint32_t h)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     UnbridgeImageFunc(emu, (XImage*)image);
     int32_t r = my->XPutImage(disp, drawable, gc, image, src_x, src_y, dst_x, dst_y, w, h);
     // bridge all access functions...
@@ -902,8 +851,6 @@ EXPORT void* my_XGetSubImage(x64emu_t* emu, void* disp, void* drawable
                     , uint32_t w, uint32_t h, uint32_t plane, int32_t fmt
                     , void* image, int32_t dst_x, int32_t dst_y)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
 
     UnbridgeImageFunc(emu, (XImage*)image);
     XImage *img = my->XGetSubImage(disp, drawable, x, y, w, h, plane, fmt, image, dst_x, dst_y);
@@ -916,8 +863,6 @@ EXPORT void* my_XGetSubImage(x64emu_t* emu, void* disp, void* drawable
 
 EXPORT void my_XDestroyImage(x64emu_t* emu, void* image)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
 
     UnbridgeImageFunc(emu, (XImage*)image);
     my->XDestroyImage(image);
@@ -937,53 +882,38 @@ typedef struct xintasync_s {
 
 EXPORT void my__XDeqAsyncHandler(x64emu_t* emu, void* cb, void* data)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     my->_XDeqAsyncHandler(findXInternalAsyncHandlerFct(cb), data);
 }
 
 EXPORT void* my_XESetWireToEvent(x64emu_t* emu, void* display, int32_t event_number, void* proc)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     void* ret = NULL;
 
     ret = my->XESetWireToEvent(display, event_number, findwire_to_eventFct(proc));
 
-    return reverse_wire_to_eventFct(lib, ret);
+    return reverse_wire_to_eventFct(my_lib, ret);
 }
 EXPORT void* my_XESetEventToWire(x64emu_t* emu, void* display, int32_t event_number, void* proc)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     void* ret = NULL;
 
     ret = my->XESetEventToWire(display, event_number, findevent_to_wireFct(proc));
 
-    return reverse_event_to_wireFct(lib, ret);
+    return reverse_event_to_wireFct(my_lib, ret);
 }
 
 EXPORT int my_XRegisterIMInstantiateCallback(x64emu_t* emu, void* d, void* db, void* res_name, void* res_class, void* cb, void* data)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
-
     return my->XRegisterIMInstantiateCallback(d, db, res_name, res_class, findregister_imFct(cb), data);
 }
     
 EXPORT int my_XUnregisterIMInstantiateCallback(x64emu_t* emu, void* d, void* db, void* res_name, void* res_class, void* cb, void* data)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
-
-    return my->XUnregisterIMInstantiateCallback(d, db, res_name, res_class, reverse_register_imFct(lib, cb), data);
+    return my->XUnregisterIMInstantiateCallback(d, db, res_name, res_class, reverse_register_imFct(my_lib, cb), data);
 }
 
 EXPORT int my_XQueryExtension(x64emu_t* emu, void* display, char* name, int* major, int* first_event, int* first_error)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
-
     int ret = my->XQueryExtension(display, name, major, first_event, first_error);
     if(!ret && name && !strcmp(name, "GLX") && x11glx) {
         // hack to force GLX to be accepted, even if not present
@@ -995,34 +925,23 @@ EXPORT int my_XQueryExtension(x64emu_t* emu, void* display, char* name, int* maj
 
 EXPORT int my_XAddConnectionWatch(x64emu_t* emu, void* display, char* f, void* data)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
-
     return my->XAddConnectionWatch(display, findXConnectionWatchProcFct(f), data);
 }
 
 EXPORT int my_XRemoveConnectionWatch(x64emu_t* emu, void* display, char* f, void* data)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
-
     return my->XRemoveConnectionWatch(display, findXConnectionWatchProcFct(f), data);
 }
 
 EXPORT void* my_XSetAfterFunction(x64emu_t* emu, void* display, void* f)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
 
-    return reverse_XSynchronizeProcFct(lib, my->XSetAfterFunction(display, findXSynchronizeProcFct(f)));
+    return reverse_XSynchronizeProcFct(my_lib, my->XSetAfterFunction(display, findXSynchronizeProcFct(f)));
 }
 
 EXPORT void* my_XSynchronize(x64emu_t* emu, void* display, int onoff)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
-
-    return reverse_XSynchronizeProcFct(lib, my->XSynchronize(display, onoff));
+    return reverse_XSynchronizeProcFct(my_lib, my->XSynchronize(display, onoff));
 }
 
 typedef unsigned long XID;
@@ -1178,8 +1097,6 @@ typedef struct my_XDisplay_s
 
 EXPORT void* my_XOpenDisplay(x64emu_t* emu, void* d)
 {
-    library_t* lib = emu->context->x11lib;
-    x11_my_t *my = (x11_my_t *)lib->priv.w.p2;
     void* ret = my->XOpenDisplay(d);
     // Added automatic bridge because of thos macro from Xlibint.h
     //#define LockDisplay(d)       if ((d)->lock_fns) (*(d)->lock_fns->lock_display)(d)
@@ -1237,12 +1154,11 @@ EXPORT void* my_XOpenDisplay(x64emu_t* emu, void* d)
 
 #define CUSTOM_INIT                 \
     box64->x11lib = lib;            \
-    lib->priv.w.p2 = getX11My(lib); \
-    if(x11threads) ((x11_my_t*)lib->priv.w.p2)->XInitThreads();
+    getMy(lib);                     \
+    if(x11threads) my->XInitThreads();
 
 #define CUSTOM_FINI \
-    freeX11My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);   \
+    freeMy(); \
     ((box64context_t*)(lib->context))->x11lib = NULL; \
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibxcbdri2.c b/src/wrapped/wrappedlibxcbdri2.c
index 1a474f9d..4745c51c 100755
--- a/src/wrapped/wrappedlibxcbdri2.c
+++ b/src/wrapped/wrappedlibxcbdri2.c
@@ -19,6 +19,5 @@
 
 const char* libxcbdri2Name = "libxcb-dri2.so.0";
 #define LIBNAME libxcbdri2
-static library_t *my_lib = NULL;
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibxcbdri3.c b/src/wrapped/wrappedlibxcbdri3.c
index 494fc462..a0a85426 100755
--- a/src/wrapped/wrappedlibxcbdri3.c
+++ b/src/wrapped/wrappedlibxcbdri3.c
@@ -19,6 +19,5 @@
 
 const char* libxcbdri3Name = "libxcb-dri3.so.0";
 #define LIBNAME libxcbdri3
-static library_t *my_lib = NULL;
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibxext.c b/src/wrapped/wrappedlibxext.c
index bc217ca3..56c563bc 100755
--- a/src/wrapped/wrappedlibxext.c
+++ b/src/wrapped/wrappedlibxext.c
@@ -19,7 +19,6 @@
 
 const char* libxextName = "libXext.so.6";
 #define LIBNAME libxext
-static library_t* my_lib = NULL;
 
 typedef struct _XImage XImage;
 void BridgeImageFunc(x64emu_t *emu, XImage *img);
@@ -43,28 +42,7 @@ typedef struct my_XExtensionHooks {
 
 #include "generated/wrappedlibxexttypes.h"
 
-typedef struct xext_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} xext_my_t;
-
-void* getXextMy(library_t* lib)
-{
-    xext_my_t* my = (xext_my_t*)calloc(1, sizeof(xext_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeXextMy(void* lib)
-{
-    (void)lib;
-    //xext_my_t *my = (xext_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -111,8 +89,6 @@ static void* reverse_exterrorhandleFct(void* fct)
 EXPORT void* my_XShmCreateImage(x64emu_t* emu, void* disp, void* vis, uint32_t depth, int32_t fmt
                     , void* data, void* shminfo, uint32_t w, uint32_t h)
 {
-    xext_my_t *my = (xext_my_t*)my_lib->priv.w.p2;
-
     XImage *img = my->XShmCreateImage(disp, vis, depth, fmt, data, shminfo, w, h);
     if(!img)
         return img;
@@ -125,8 +101,6 @@ EXPORT int32_t my_XShmPutImage(x64emu_t* emu, void* disp, void* drawable, void*
                     , int32_t src_x, int32_t src_y, int32_t dst_x, int32_t dst_y
                     , uint32_t w, uint32_t h, int32_t sendevt)
 {
-    xext_my_t *my = (xext_my_t*)my_lib->priv.w.p2;
-
     UnbridgeImageFunc(emu, (XImage*)image);
     int32_t r = my->XShmPutImage(disp, drawable, gc, image, src_x, src_y, dst_x, dst_y, w, h, sendevt);
     // bridge all access functions...
@@ -136,8 +110,6 @@ EXPORT int32_t my_XShmPutImage(x64emu_t* emu, void* disp, void* drawable, void*
 
 EXPORT int32_t my_XShmGetImage(x64emu_t* emu, void* disp, void* drawable, void* image, int32_t x, int32_t y, uint32_t plane)
 {
-    xext_my_t *my = (xext_my_t*)my_lib->priv.w.p2;
-
     UnbridgeImageFunc(emu, (XImage*)image);
     int32_t r = my->XShmGetImage(disp, drawable, image, x, y, plane);
     // bridge all access functions...
@@ -148,7 +120,6 @@ EXPORT int32_t my_XShmGetImage(x64emu_t* emu, void* disp, void* drawable, void*
 EXPORT void* my_XSetExtensionErrorHandler(x64emu_t* emu, void* handler)
 {
     (void)emu;
-    xext_my_t *my = (xext_my_t*)my_lib->priv.w.p2;
     return reverse_exterrorhandleFct(my->XSetExtensionErrorHandler(find_exterrorhandle_Fct(handler)));
 }
 
@@ -222,8 +193,6 @@ static char* my_hook_error_string(void* a, int b, void* c, void* d, int e) {
 
 EXPORT void* my_XextAddDisplay(x64emu_t* emu, void* extinfo, void* dpy, void* extname, my_XExtensionHooks* hooks, int nevents, void* data)
 {
-    xext_my_t *my = (xext_my_t*)my_lib->priv.w.p2;
-
     if(!context)
         context = emu->context;
 
@@ -245,20 +214,16 @@ EXPORT void* my_XextAddDisplay(x64emu_t* emu, void* extinfo, void* dpy, void* ex
     return ret;
 }
 
-#define CUSTOM_INIT \
-    lib->priv.w.p2 = getXextMy(lib);    \
-    my_lib = lib;                       \
-    lib->priv.w.needed = 5;             \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libxcb.so.1"); \
-    lib->priv.w.neededlibs[2] = strdup("libXau.so.6"); \
-    lib->priv.w.neededlibs[3] = strdup("libdl.so.2");  \
-    lib->priv.w.neededlibs[4] = strdup("libXdmcp.so.6");
+#define CUSTOM_INIT                 \
+    getMy(lib);                     \
+    setNeededLibs(&lib->priv.w, 5,  \
+        "libX11.so.6",              \
+        "libxcb.so.1",              \
+        "libXau.so.6",              \
+        "libdl.so.2",               \
+        "libXdmcp.so.6");
 
 #define CUSTOM_FINI \
-    freeXextMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibxfixes.c b/src/wrapped/wrappedlibxfixes.c
index 4ad17a8a..6d97b551 100755
--- a/src/wrapped/wrappedlibxfixes.c
+++ b/src/wrapped/wrappedlibxfixes.c
@@ -15,12 +15,11 @@ const char* libxfixesName = "libXfixes.so.3";
 #define LIBNAME libxfixes
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 4; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libxcb.so.1"); \
-    lib->priv.w.neededlibs[2] = strdup("libXau.so.6"); \
-    lib->priv.w.neededlibs[3] = strdup("libXdmcp.so.6");
+    setNeededLibs(&lib->priv.w, 4,  \
+        "libX11.so.6",              \
+        "libxcb.so.1",              \
+        "libXau.so.6",              \
+        "libXdmcp.so.6");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibxft.c b/src/wrapped/wrappedlibxft.c
index 4fa6e083..9280239c 100755
--- a/src/wrapped/wrappedlibxft.c
+++ b/src/wrapped/wrappedlibxft.c
@@ -15,12 +15,11 @@ const char* libxftName = "libXft.so.2";
 #define LIBNAME libxft
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 4; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6");          \
-    lib->priv.w.neededlibs[1] = strdup("libfontconfig.so.1");   \
-    lib->priv.w.neededlibs[2] = strdup("libXrender.so.1");      \
-    lib->priv.w.neededlibs[3] = strdup("libfreetype.so.6");
+    setNeededLibs(&lib->priv.w, 4,  \
+        "libX11.so.6",              \
+        "libfontconfig.so.1",       \
+        "libXrender.so.1",          \
+        "libfreetype.so.6");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibxi.c b/src/wrapped/wrappedlibxi.c
index 9f1005b0..57458dcd 100755
--- a/src/wrapped/wrappedlibxi.c
+++ b/src/wrapped/wrappedlibxi.c
@@ -15,10 +15,7 @@ const char* libxiName = "libXi.so.6";
 #define LIBNAME libxi
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6");
+    setNeededLibs(&lib->priv.w, 2, "libX11.so.6", "libXext.so.6");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibxmu.c b/src/wrapped/wrappedlibxmu.c
index c7262418..24c75d4e 100755
--- a/src/wrapped/wrappedlibxmu.c
+++ b/src/wrapped/wrappedlibxmu.c
@@ -15,10 +15,7 @@ const char* libxmuName = "libXmu.so.6";
 #define LIBNAME libxmu
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6");
+    setNeededLibs(&lib->priv.w, 2, "libX11.so.6", "libXext.so.6");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibxpm.c b/src/wrapped/wrappedlibxpm.c
index 17dbb0ec..38fd353f 100755
--- a/src/wrapped/wrappedlibxpm.c
+++ b/src/wrapped/wrappedlibxpm.c
@@ -14,10 +14,7 @@
 const char* libxpmName = "libXpm.so.4";
 #define LIBNAME libxpm
 
-#include "wrappedlib_init.h"
-
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6");
+    setNeededLibs(&lib->priv.w, 2, "libX11.so.6", "libXext.so.6");
+
+#include "wrappedlib_init.h"
\ No newline at end of file
diff --git a/src/wrapped/wrappedlibxrandr.c b/src/wrapped/wrappedlibxrandr.c
index 29240046..054864ae 100755
--- a/src/wrapped/wrappedlibxrandr.c
+++ b/src/wrapped/wrappedlibxrandr.c
@@ -21,10 +21,9 @@ const char* libxrandrName = "libXrandr.so.2";
 #define LIBNAME libxrandr
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 3; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6"); \
-    lib->priv.w.neededlibs[2] = strdup("libXrender.so.1");
+    setNeededLibs(&lib->priv.w, 3,  \
+        "libX11.so.6",              \
+        "libXext.so.6",             \
+        "libXrender.so.1");
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibxrender.c b/src/wrapped/wrappedlibxrender.c
index 343951e1..b6aefe24 100755
--- a/src/wrapped/wrappedlibxrender.c
+++ b/src/wrapped/wrappedlibxrender.c
@@ -15,12 +15,11 @@ const char* libxrenderName = "libXrender.so.1";
 #define LIBNAME libxrender
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 4; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libxcb.so.1"); \
-    lib->priv.w.neededlibs[2] = strdup("libXau.so.6"); \
-    lib->priv.w.neededlibs[3] = strdup("libXdmcp.so.6");
+    setNeededLibs(&lib->priv.w, 4,  \
+        "libX11.so.6",              \
+        "libxcb.so.1",              \
+        "libXau.so.6",              \
+        "libXdmcp.so.6");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedlibxss.c b/src/wrapped/wrappedlibxss.c
index 4abb9ce9..277cb7e9 100755
--- a/src/wrapped/wrappedlibxss.c
+++ b/src/wrapped/wrappedlibxss.c
@@ -14,10 +14,7 @@
 const char* libxssName = "libXss.so.1";
 #define LIBNAME libxss
 
-#include "wrappedlib_init.h"
-
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6");
+    setNeededLibs(&lib->priv.w, 2, "libX11.so.6", "libXext.so.6");
+
+#include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibxt.c b/src/wrapped/wrappedlibxt.c
index d432e50a..6f819d06 100755
--- a/src/wrapped/wrappedlibxt.c
+++ b/src/wrapped/wrappedlibxt.c
@@ -22,31 +22,7 @@ const char* libxtName = "libXt.so.6";
 
 #include "generated/wrappedlibxttypes.h"
 
-typedef struct libxt_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libxt_my_t;
-
-static library_t* my_lib = NULL;
-void* getXtMy(library_t* lib)
-{
-    my_lib = lib;
-    libxt_my_t* my = (libxt_my_t*)calloc(1, sizeof(libxt_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeXtMy(void* lib)
-{
-    my_lib = NULL;
-    (void)lib;
-    //libxt_my_t *my = (libxt_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -131,36 +107,26 @@ EXPORT void my_XtAddEventHandler(x64emu_t* emu, void* w, uint32_t mask, int32_t
 {
     (void)emu;
     void* fct = findEventFct(cb);
-    libxt_my_t* my = (libxt_my_t*)my_lib->priv.w.p2;
-
     my->XtAddEventHandler(w, mask, maskable, fct, data);
 }
 
 EXPORT long my_XtAppAddWorkProc(x64emu_t* emu, void* context, void* proc, void* data)
 {
     (void)emu;
-    libxt_my_t* my = (libxt_my_t*)my_lib->priv.w.p2;
-
     return my->XtAppAddWorkProc(context, findWorkProcFct(proc), data);
 }
 
 EXPORT long my_XtAppAddInput(x64emu_t* emu, void* context, int source, void* cond, void* proc, void* data)
 {
     (void)emu;
-    libxt_my_t* my = (libxt_my_t*)my_lib->priv.w.p2;
-
     return my->XtAppAddInput(context, source, cond, findInputCallbackFct(proc), data);
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getXtMy(lib);   \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6");
+    getMy(lib);   \
+    setNeededLibs(&lib->priv.w, 2, "libX11.so.6", "libXext.so.6");
 
 #define CUSTOM_FINI \
-    freeXtMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibxtst.c b/src/wrapped/wrappedlibxtst.c
index df7b14c4..a99be56f 100755
--- a/src/wrapped/wrappedlibxtst.c
+++ b/src/wrapped/wrappedlibxtst.c
@@ -22,28 +22,7 @@ const char* libxtstName = "libXtst.so.6";
 
 #include "generated/wrappedlibxtsttypes.h"
 
-typedef struct libxtst_my_s {
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-    // functions
-} libxtst_my_t;
-
-void* getXtstMy(library_t* lib)
-{
-    libxtst_my_t* my = (libxtst_my_t*)calloc(1, sizeof(libxtst_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeXtstMy(void* lib)
-{
-    (void)lib;
-    //libxtst_my_t *my = (libxtst_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -78,28 +57,20 @@ static void* find_XRecordInterceptProc_Fct(void* fct)
 EXPORT int my_XRecordEnableContextAsync(x64emu_t* emu, void* display, void* context, void* cb, void* closure)
 {
     (void)emu;
-    library_t* lib = GetLibInternal(libxtstName);
-    libxtst_my_t* my = (libxtst_my_t*)lib->priv.w.p2;
     return my->XRecordEnableContextAsync(display, context, find_XRecordInterceptProc_Fct(cb), closure);
 }
 
 EXPORT int my_XRecordEnableContext(x64emu_t* emu, void* display, void* context, void* cb, void* closure)
 {
     (void)emu;
-    library_t* lib = GetLibInternal(libxtstName);
-    libxtst_my_t* my = (libxtst_my_t*)lib->priv.w.p2;
     return my->XRecordEnableContext(display, context, find_XRecordInterceptProc_Fct(cb), closure);
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getXtstMy(lib);   \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6");
+    getMy(lib);     \
+    setNeededLibs(&lib->priv.w, 2, "libX11.so.6", "libXext.so.6");
 
 #define CUSTOM_FINI \
-    freeXtstMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibxxf86vm.c b/src/wrapped/wrappedlibxxf86vm.c
index bc956d0b..9ac4a3c4 100755
--- a/src/wrapped/wrappedlibxxf86vm.c
+++ b/src/wrapped/wrappedlibxxf86vm.c
@@ -22,9 +22,6 @@ const char* libxxf86vmName = "libXxf86vm.so.1";
 
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6");
+    setNeededLibs(&lib->priv.w, 2, "libX11.so.6", "libXext.so.6");
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlibz.c b/src/wrapped/wrappedlibz.c
index a6e5e3d3..75f77e96 100755
--- a/src/wrapped/wrappedlibz.c
+++ b/src/wrapped/wrappedlibz.c
@@ -20,29 +20,7 @@ const char* libzName = "libz.so.1";
 
 #include "generated/wrappedlibztypes.h"
 
-typedef struct libz_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} libz_my_t;
-
-
-void* getZMy(library_t* lib)
-{
-    libz_my_t* my = (libz_my_t*)calloc(1, sizeof(libz_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeZMy(void* lib)
-{
-    (void)lib;
-    //libz_my_t *my = (libz_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -124,21 +102,18 @@ static void wrapper_stream_z(x64emu_t* emu, void* str)
 
 EXPORT int my_inflateInit_(x64emu_t* emu, void* str, void* version, int size)
 {
-    libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2;
     wrapper_stream_z(emu, str);
     return my->inflateInit_(str, version, size);
 }
 
 EXPORT int my_inflateInit2_(x64emu_t* emu, void* str, int windowBits, void* version, int stream_size)
 {
-    libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2;
     wrapper_stream_z(emu, str);
     return my->inflateInit2_(str, windowBits, version, stream_size);
 }
 
 EXPORT int my_inflateBackInit_(x64emu_t* emu, void* strm, int windowBits, void *window, void* version, int size)
 {
-    libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2;
     wrapper_stream_z(emu, strm);
     return my->inflateBackInit_(strm, windowBits, window, version, size);
 }
@@ -146,21 +121,18 @@ EXPORT int my_inflateBackInit_(x64emu_t* emu, void* strm, int windowBits, void *
 // TODO: remove this?
 EXPORT int my_inflateEnd(x64emu_t* emu, void* str)
 {
-    libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2;
     int r = my->inflateEnd(str);
     return r;
 }
 
 EXPORT int my_deflateInit_(x64emu_t* emu, void* str, int level, void* version, int stream_size)
 {
-    libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2;
     wrapper_stream_z(emu, str);
     return my->deflateInit_(str, level, version, stream_size);
 }
 
 EXPORT int my_deflateInit2_(x64emu_t* emu, void* str, int level, int method, int windowBits, int memLevel, int strategy, void* version, int stream_size)
 {
-    libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2;
     wrapper_stream_z(emu, str);
     return my->deflateInit2_(str, level, method, windowBits, memLevel, strategy, version, stream_size);
 }
@@ -168,14 +140,12 @@ EXPORT int my_deflateInit2_(x64emu_t* emu, void* str, int level, int method, int
 // TODO: remove this?
 EXPORT int my_deflateEnd(x64emu_t* emu, void* str)
 {
-    libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2;
     int r = my->deflateEnd(str);
     return r;
 }
 
 EXPORT int my_inflate(x64emu_t* emu, void* str, int flush)
 {
-    libz_my_t *my = (libz_my_t *)emu->context->zlib->priv.w.p2;
     wrapper_stream_z(emu, str);
     return my->inflate(str, flush);
     //TODO: should unwrap the stream
@@ -185,11 +155,10 @@ EXPORT int my_inflate(x64emu_t* emu, void* str, int flush)
 
 #define CUSTOM_INIT \
     box64->zlib = lib; \
-    lib->priv.w.p2 = getZMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeZMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2); \
+    freeMy(); \
     ((box64context_t*)(lib->context))->zlib = NULL;
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedlzma.c b/src/wrapped/wrappedlzma.c
index f364d45d..2862e491 100755
--- a/src/wrapped/wrappedlzma.c
+++ b/src/wrapped/wrappedlzma.c
@@ -20,34 +20,10 @@
 
 const char* lzmaName = "liblzma.so.5";
 #define LIBNAME lzma
-static library_t* my_lib = NULL;
-
 
 #include "generated/wrappedlzmatypes.h"
 
-typedef struct lzma_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} lzma_my_t;
-
-void* getLzmaMy(library_t* lib)
-{
-    lzma_my_t* my = (lzma_my_t*)calloc(1, sizeof(lzma_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    (void)lib; // So many wrapped functions here
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeLzmaMy(void* lib)
-{
-    (void)lib;
-    //lzma_my_t *my = (lzma_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 typedef struct lzma_allocator_s {
 	void *(*alloc)(void *opaque, size_t nmemb, size_t size);
@@ -120,7 +96,6 @@ static void wrap_alloc_struct(lzma_allocator_t* dst, lzma_allocator_t* src)
 
 EXPORT int my_lzma_index_buffer_decode(x64emu_t* emu, void* i, void* memlimit, lzma_allocator_t* alloc, void* in_, void* in_pos, size_t in_size)
 {
-    lzma_my_t *my = (lzma_my_t *)my_lib->priv.w.p2;
     lzma_allocator_t allocator = {0};
     wrap_alloc_struct(&allocator, alloc);
     return my->lzma_index_buffer_decode(i, memlimit, alloc?&allocator:NULL, in_, in_pos, in_size);
@@ -128,7 +103,6 @@ EXPORT int my_lzma_index_buffer_decode(x64emu_t* emu, void* i, void* memlimit, l
 
 EXPORT void my_lzma_index_end(x64emu_t* emu, void* i, lzma_allocator_t* alloc)
 {
-    lzma_my_t *my = (lzma_my_t *)my_lib->priv.w.p2;
     lzma_allocator_t allocator = {0};
     wrap_alloc_struct(&allocator, alloc);
     return my->lzma_index_end(i,alloc?&allocator:NULL);
@@ -136,7 +110,6 @@ EXPORT void my_lzma_index_end(x64emu_t* emu, void* i, lzma_allocator_t* alloc)
 
 EXPORT int my_lzma_stream_buffer_decode(x64emu_t* emu, void* memlimit, uint32_t flags, lzma_allocator_t* alloc, void* in_, void* in_pos, size_t in_size, void* out_, void* out_pos, size_t out_size)
 {
-    lzma_my_t *my = (lzma_my_t *)my_lib->priv.w.p2;
     lzma_allocator_t allocator = {0};
     wrap_alloc_struct(&allocator, alloc);
     return my->lzma_stream_buffer_decode(memlimit, flags, alloc?&allocator:NULL, in_, in_pos, in_size, out_, out_pos, out_size);
@@ -144,12 +117,9 @@ EXPORT int my_lzma_stream_buffer_decode(x64emu_t* emu, void* memlimit, uint32_t
 
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getLzmaMy(lib); \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeLzmaMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedmpg123.c b/src/wrapped/wrappedmpg123.c
index 3b3fc123..80d80cce 100755
--- a/src/wrapped/wrappedmpg123.c
+++ b/src/wrapped/wrappedmpg123.c
@@ -20,35 +20,11 @@
 const char* mpg123Name = "libmpg123.so.0";
 #define LIBNAME mpg123
 
-typedef int (*iFpppp_t) (void*, void*, void*, void*);
+#define ADDED_FUNCTIONS()           \
 
-#define SUPER() \
-    GO(mpg123_replace_reader_handle, iFpppp_t)      \
-    GO(mpg123_replace_reader_handle_32, iFpppp_t)   \
-    GO(mpg123_replace_reader_handle_64, iFpppp_t)   \
-
-typedef struct mpg123_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} mpg123_my_t;
-
-void* getMpg123My(library_t* lib)
-{
-    mpg123_my_t* my = (mpg123_my_t*)calloc(1, sizeof(mpg123_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeMpg123My(void* lib)
-{
-    //mpg123_my_t *my = (mpg123_my_t *)lib;
-}
+#include "generated/wrappedmpg123types.h"
 
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -128,34 +104,24 @@ static void* find_cleanup_Fct(void* fct)
 
 EXPORT int my_mpg123_replace_reader_handle(x64emu_t* emu, void* mh, void* r_read, void* r_lseek, void* cleanup)
 {
-    library_t * lib = GetLibInternal(mpg123Name);
-    mpg123_my_t *my = (mpg123_my_t*)lib->priv.w.p2;
-
     return my->mpg123_replace_reader_handle(mh, find_r_read_Fct(r_read), find_r_lseek_Fct(r_lseek), find_cleanup_Fct(cleanup));
 }
 
 EXPORT int my_mpg123_replace_reader_handle_32(x64emu_t* emu, void* mh, void* r_read, void* r_lseek, void* cleanup)
 {
-    library_t * lib = GetLibInternal(mpg123Name);
-    mpg123_my_t *my = (mpg123_my_t*)lib->priv.w.p2;
-
     return my->mpg123_replace_reader_handle_32(mh, find_r_read_Fct(r_read), find_r_lseek_Fct(r_lseek), find_cleanup_Fct(cleanup));
 }
 
 EXPORT int my_mpg123_replace_reader_handle_64(x64emu_t* emu, void* mh, void* r_read, void* r_lseek, void* cleanup)
 {
-    library_t * lib = GetLibInternal(mpg123Name);
-    mpg123_my_t *my = (mpg123_my_t*)lib->priv.w.p2;
-
     return my->mpg123_replace_reader_handle_64(mh, find_r_read_Fct(r_read), find_r_lseek_Fct(r_lseek), find_cleanup_Fct(cleanup));
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getMpg123My(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeMpg123My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappednss3.c b/src/wrapped/wrappednss3.c
index 83227ba9..76a0acdc 100755
--- a/src/wrapped/wrappednss3.c
+++ b/src/wrapped/wrappednss3.c
@@ -20,33 +20,10 @@
 
 const char* nss3Name = "libnss3.so";
 #define LIBNAME nss3
-static library_t *my_lib = NULL;
 
 #include "generated/wrappednss3types.h"
 
-typedef struct nss3_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} nss3_my_t;
-
-void* getNss3My(library_t* lib)
-{
-    my_lib = lib;
-    nss3_my_t* my = (nss3_my_t*)calloc(1, sizeof(nss3_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeNss3My(void* lib)
-{
-    //nss3_my_t *my = (nss3_my_t *)lib;
-}
-
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -82,17 +59,14 @@ static void* find_PK11PasswordFunc_Fct(void* fct)
 
 EXPORT void my_PK11_SetPasswordFunc(x64emu_t* emu, void* f)
 {
-    nss3_my_t* my = (nss3_my_t*)my_lib->priv.w.p2;
-
     my->PK11_SetPasswordFunc(find_PK11PasswordFunc_Fct(f));
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getNss3My(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeNss3My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedopenal.c b/src/wrapped/wrappedopenal.c
index 224431ee..96cc1bb6 100755
--- a/src/wrapped/wrappedopenal.c
+++ b/src/wrapped/wrappedopenal.c
@@ -24,28 +24,7 @@ static char* libname = NULL;
 
 #include "generated/wrappedopenaltypes.h"
 
-typedef struct openal_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} openal_my_t;
-
-void* getOpenALMy(library_t* lib)
-{
-    openal_my_t* my = (openal_my_t*)calloc(1, sizeof(openal_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeOpenALMy(void* lib)
-{
-    (void)lib;
-    //openal_my_t *my = (openal_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -86,17 +65,16 @@ void my_alRequestFoldbackStop(x64emu_t* emu);
 
 #define CUSTOM_INIT \
     libname = lib->name;                \
-    lib->priv.w.p2 = getOpenALMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeOpenALMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
 
 
 
-void fillALProcWrapper(box64context_t* context)
+void fillALProcWrapper()
 {
     int cnt, ret;
     khint_t k;
@@ -113,7 +91,7 @@ void fillALProcWrapper(box64context_t* context)
         k = kh_put(symbolmap, symbolmap, openalmysymbolmap[i].name, &ret);
         kh_value(symbolmap, k) = openalmysymbolmap[i].w;
     }
-    context->alwrappers = symbolmap;
+    my_context->alwrappers = symbolmap;
     // fill my_* map
     symbolmap = kh_init(symbolmap);
     cnt = sizeof(MAPNAME(mysymbolmap))/sizeof(map_onesymbol_t);
@@ -121,7 +99,7 @@ void fillALProcWrapper(box64context_t* context)
         k = kh_put(symbolmap, symbolmap, openalmysymbolmap[i].name, &ret);
         kh_value(symbolmap, k) = openalmysymbolmap[i].w;
     }
-    context->almymap = symbolmap;
+    my_context->almymap = symbolmap;
 }
 void freeALProcWrapper(box64context_t* context)
 {
@@ -138,7 +116,6 @@ void freeALProcWrapper(box64context_t* context)
 EXPORT void* my_alGetProcAddress(x64emu_t* emu, void* name) 
 {
     khint_t k;
-    openal_my_t* my = (openal_my_t*)GetLibInternal(libname)->priv.w.p2;
     const char* rname = (const char*)name;
     printf_log(LOG_DEBUG, "Calling alGetProcAddress(%s)\n", rname);
     if(!emu->context->alwrappers)   // could be moved in "my" structure...
@@ -175,11 +152,10 @@ EXPORT void* my_alGetProcAddress(x64emu_t* emu, void* name)
 EXPORT void* my_alcGetProcAddress(x64emu_t* emu, void* device, void* name)
 {
     khint_t k;
-    openal_my_t* my = (openal_my_t*)GetLibInternal(libname)->priv.w.p2;
     const char* rname = (const char*)name;
     printf_log(LOG_DEBUG, "Calling alcGetProcAddress(%p, %s)\n", device, rname);
     if(!emu->context->alwrappers)   // could be moved in "my" structure...
-        fillALProcWrapper(emu->context);
+        fillALProcWrapper();
     // get proc adress using actual alGetProcAddress
     k = kh_get(symbolmap, emu->context->almymap, rname);
     int is_my = (k==kh_end(emu->context->almymap))?0:1;
@@ -211,13 +187,11 @@ EXPORT void* my_alcGetProcAddress(x64emu_t* emu, void* device, void* name)
 EXPORT void my_alRequestFoldbackStart(x64emu_t *emu, int32_t mode, int32_t count, int32_t length, void* mem, void* cb)
 {
     (void)emu;
-    openal_my_t* my = (openal_my_t*)GetLibInternal(libname)->priv.w.p2;
     my->alRequestFoldbackStart(mode, count, length, mem, find_Request_Fct(cb));
 }
 
 EXPORT void my_alRequestFoldbackStop(x64emu_t* emu)
 {
     (void)emu;
-    openal_my_t* my = (openal_my_t*)GetLibInternal(libname)->priv.w.p2;
     my->alRequestFoldbackStop();
 }
diff --git a/src/wrapped/wrappedpango.c b/src/wrapped/wrappedpango.c
index de6a206e..52f73af8 100755
--- a/src/wrapped/wrappedpango.c
+++ b/src/wrapped/wrappedpango.c
@@ -19,32 +19,10 @@
 
 const char* pangoName = "libpango-1.0.so.0";
 #define LIBNAME pango
-static library_t *my_lib = NULL;
 
 #include "generated/wrappedpangotypes.h"
 
-typedef struct pango_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} pango_my_t;
-
-void* getPangoMy(library_t* lib)
-{
-    pango_my_t* my = (pango_my_t*)calloc(1, sizeof(pango_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freePangoMy(void* lib)
-{
-    (void)lib;
-    //pango_my_t *my = (pango_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 typedef struct my_PangoAttrClass_s {
   int                type;
@@ -111,7 +89,6 @@ static void* find_PangoAttrClass_Fct(my_PangoAttrClass_t* klass)
 EXPORT void my_pango_attribute_init(x64emu_t* emu, void* attr, my_PangoAttrClass_t* klass)
 {
     (void)emu;
-    pango_my_t* my = (pango_my_t*)my_lib->priv.w.p2;
     my->pango_attribute_init(attr, find_PangoAttrClass_Fct(klass));
 }
 
@@ -120,16 +97,10 @@ EXPORT void my_pango_attribute_init(x64emu_t* emu, void* attr, my_PangoAttrClass
         return -1;
 
 #define CUSTOM_INIT \
-    my_lib = lib;                   \
-    lib->priv.w.p2 = getPangoMy(lib); \
-    lib->priv.w.needed = 2;         \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libgobject-2.0.so.0");                  \
-    lib->priv.w.neededlibs[1] = strdup("libglib-2.0.so.0");
+    getMy(lib); \
+    setNeededLibs(&lib->priv.w, 2, "libgobject-2.0.so.0", "libglib-2.0.so.0");
 
 #define CUSTOM_FINI \
-    my_lib = NULL;              \
-    freePangoMy(lib->priv.w.p2);  \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedpangocairo.c b/src/wrapped/wrappedpangocairo.c
index b7516dd0..19e8cb6b 100755
--- a/src/wrapped/wrappedpangocairo.c
+++ b/src/wrapped/wrappedpangocairo.c
@@ -16,9 +16,7 @@ const char* pangocairoName = "libpangocairo-1.0.so.0";
 #define LIBNAME pangocairo
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libpango-1.0.so.0");
+    setNeededLibs(&lib->priv.w, 1, "libpango-1.0.so.0");
 
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedpangoft2.c b/src/wrapped/wrappedpangoft2.c
index 3a9aa7cf..37efa6d0 100755
--- a/src/wrapped/wrappedpangoft2.c
+++ b/src/wrapped/wrappedpangoft2.c
@@ -15,9 +15,6 @@ const char* pangoft2Name = "libpangoft2-1.0.so.0";
 #define LIBNAME pangoft2
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libfontconfig.so.1");                  \
-    lib->priv.w.neededlibs[1] = strdup("libfreetype.so.6");
+    setNeededLibs(&lib->priv.w, 2, "libfontconfig.so.1", "libfreetype.so.6");
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedpng16.c b/src/wrapped/wrappedpng16.c
index c537b5a0..22bb9e5a 100755
--- a/src/wrapped/wrappedpng16.c
+++ b/src/wrapped/wrappedpng16.c
@@ -28,27 +28,7 @@ const char* png16Name =
 
 #include "generated/wrappedpng16types.h"
 
-typedef struct png16_my_s {
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-    // functions
-} png16_my_t;
-
-void* getPng16My(library_t* lib)
-{
-    png16_my_t* my = (png16_my_t*)calloc(1, sizeof(png16_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A); if(!my->A) my->A = (W)dlsym(lib->priv.w.lib, "yes" #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freePng16My(void* lib)
-{
-    //png16_my_t *my = (png16_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -308,75 +288,50 @@ static void* finduser_transformFct(void* fct)
 
 EXPORT void my16_png_set_read_fn(x64emu_t *emu, void* png_ptr, void* io_ptr, void* read_data_fn)
 {
-    library_t * lib = GetLibInternal(png16Name);
-    png16_my_t *my = (png16_my_t*)lib->priv.w.p2;
-
     my->png_set_read_fn(png_ptr, io_ptr, finduser_readFct(read_data_fn));
 }
 
 EXPORT void my16_png_set_read_user_transform_fn(x64emu_t *emu, void* png_ptr, void* read_transform_fn)
 {
-    library_t * lib = GetLibInternal(png16Name);
-    png16_my_t *my = (png16_my_t*)lib->priv.w.p2;
-
     my->png_set_read_user_transform_fn(png_ptr, finduser_transformFct(read_transform_fn));
 }
 
 EXPORT void my16_png_set_error_fn(x64emu_t* emu, void* pngptr, void* errorptr, void* error_fn, void* warning_fn)
 {
-    library_t * lib = GetLibInternal(png16Name);
-    png16_my_t *my = (png16_my_t*)lib->priv.w.p2;
-
     my->png_set_error_fn(pngptr, errorptr, finderrorFct(error_fn), findwarningFct(warning_fn));
 }
 
 EXPORT void my16_png_set_write_fn(x64emu_t* emu, void* png_ptr, void* io_ptr, void* write_fn, void* flush_fn)
 {
-    library_t * lib = GetLibInternal(png16Name);
-    png16_my_t *my = (png16_my_t*)lib->priv.w.p2;
-
     my->png_set_write_fn(png_ptr, io_ptr, finduser_writeFct(write_fn), finduser_flushFct(flush_fn));
 }
 
 EXPORT void* my16_png_create_read_struct_2(x64emu_t* emu, void* user_png_ver, void* error_ptr, void* error_fn, void* warn_fn, void* mem_ptr, void* malloc_fn, void* free_fn)
 {
-    library_t * lib = GetLibInternal(png16Name);
-    png16_my_t *my = (png16_my_t*)lib->priv.w.p2;
-
     return my->png_create_read_struct_2(user_png_ver, error_ptr, finderrorFct(error_fn), findwarningFct(warn_fn), mem_ptr, findmallocFct(malloc_fn), findfreeFct(free_fn));
 }
 
 EXPORT void* my16_png_create_write_struct_2(x64emu_t* emu, void* user_png_ver, void* error_ptr, void* error_fn, void* warn_fn, void* mem_ptr, void* malloc_fn, void* free_fn)
 {
-    library_t * lib = GetLibInternal(png16Name);
-    png16_my_t *my = (png16_my_t*)lib->priv.w.p2;
-
     return my->png_create_write_struct_2(user_png_ver, error_ptr, finderrorFct(error_fn), findwarningFct(warn_fn), mem_ptr, findmallocFct(malloc_fn), findfreeFct(free_fn));
 }
 
 EXPORT void my16_png_set_progressive_read_fn(x64emu_t* emu, void* png_ptr, void* user_ptr, void* info, void* row, void* end)
 {
-    library_t * lib = GetLibInternal(png16Name);
-    png16_my_t *my = (png16_my_t*)lib->priv.w.p2;
-
     my->png_set_progressive_read_fn(png_ptr, user_ptr, findprogressive_infoFct(info), findprogressive_rowFct(row), findprogressive_endFct(end));
 }
 
 EXPORT void* my16_png_create_read_struct(x64emu_t* emu, void* png_ptr, void* user_ptr, void* errorfn, void* warnfn)
 {
-    library_t * lib = GetLibInternal(png16Name);
-    png16_my_t *my = (png16_my_t*)lib->priv.w.p2;
-
     return my->png_create_read_struct(png_ptr, user_ptr, finderrorFct(errorfn), findwarningFct(warnfn));
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.altprefix=strdup("yes"); \
-    lib->priv.w.p2 = getPng16My(lib); \
-    lib->altmy = strdup("my16_");
+    SETALTPREFIX("yes");\
+    SETALT(my16_);      \
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freePng16My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedpulse.c b/src/wrapped/wrappedpulse.c
index 9e45b8ad..688671dc 100755
--- a/src/wrapped/wrappedpulse.c
+++ b/src/wrapped/wrappedpulse.c
@@ -57,29 +57,7 @@ typedef void (*vFipippV_t)(int, void*, int, void*, void*, void*);
 
 #include "generated/wrappedpulsetypes.h"
 
-typedef struct pulse_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} pulse_my_t;
-
-void* getPulseMy(library_t* lib)
-{
-    pulse_my_t* my = (pulse_my_t*)calloc(1, sizeof(pulse_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-
-    return my;
-}
-#undef SUPER
-
-void freePulseMy(void* lib)
-{
-    (void)lib;
-    //pulse_my_t *my = (pulse_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 // TODO: change that static for a map ptr2ptr?
 static my_pa_mainloop_api_t my_mainloop_api = {0};
@@ -841,8 +819,6 @@ static void native_quit(void* api, int retval)
 static void* my_io_new(void* api, int fd, int events, void* cb, void *userdata)
 {
     uintptr_t b = (uintptr_t)cb;
-    //pulse_my_t* my = (pulse_my_t*)my_context->pulse->priv.w.p2;
-
     void* fnc = GetNativeFnc((uintptr_t)my_mainloop_ref->io_new);
     if(fnc) {
         if(fnc==native_io_new) fnc=my_mainloop_native.io_new;
@@ -894,8 +870,6 @@ static void my_io_set_destroy(void* e, void* cb)
 static void* my_time_new(void* api, void* tv, void* cb, void* data)
 {
     uintptr_t b = (uintptr_t)cb;
-    //pulse_my_t* my = (pulse_my_t*)my_context->pulse->priv.w.p2;
-
     void* fnc = GetNativeFnc((uintptr_t)my_mainloop_ref->time_new);
     if(fnc) {
         if(fnc==native_time_new) fnc=my_mainloop_native.time_new;
@@ -945,8 +919,6 @@ static void my_time_set_destroy(void* e, void* cb)
 static void* my_defer_new(void* api, void* cb, void* data)
 {
     uintptr_t b = (uintptr_t)cb;
-    //pulse_my_t* my = (pulse_my_t*)my_context->pulse->priv.w.p2;
-
     void* fnc = GetNativeFnc((uintptr_t)my_mainloop_ref->defer_new);
     if(fnc) {
         if(api==my_mainloop_ref) api=my_mainloop_orig;    // need native version
@@ -1048,69 +1020,56 @@ static void bridgeMainloopAPI(bridge_t* bridge, my_pa_mainloop_api_t* api)
 // only one mainloop can be active at a given time!
 EXPORT void my_pa_mainloop_free(x64emu_t* emu, void* mainloop)
 {
-    library_t* lib = emu->context->pulse;
-    pulse_my_t* my = lib->priv.w.p2;
     my->pa_mainloop_free(mainloop);
     mainloop_inited = 0;
     /*my_mainloop_ref =*/ my_mainloop_orig = NULL;
 }
 EXPORT void* my_pa_mainloop_get_api(x64emu_t* emu, void* mainloop)
 {
-    library_t* lib = emu->context->pulse;
-    pulse_my_t* my = lib->priv.w.p2;
     my_pa_mainloop_api_t* api = my->pa_mainloop_get_api(mainloop);
-    bridgeMainloopAPI(lib->priv.w.bridge, api);
+    bridgeMainloopAPI(my_lib->priv.w.bridge, api);
     return my_mainloop_ref;
 }
 
 EXPORT void my_pa_threaded_mainloop_free(x64emu_t* emu, void* mainloop)
 {
-    library_t* lib = emu->context->pulse;
-    pulse_my_t* my = lib->priv.w.p2;
     my->pa_threaded_mainloop_free(mainloop);
     mainloop_inited = 0;
     /*my_mainloop_ref =*/ my_mainloop_orig = NULL;
 }
 EXPORT void* my_pa_threaded_mainloop_get_api(x64emu_t* emu, void* mainloop)
 {
-    library_t* lib = emu->context->pulse;
-    pulse_my_t* my = lib->priv.w.p2;
     my_pa_mainloop_api_t* api = my->pa_threaded_mainloop_get_api(mainloop);
-    bridgeMainloopAPI(lib->priv.w.bridge, api);
+    bridgeMainloopAPI(my_lib->priv.w.bridge, api);
     return my_mainloop_ref;
 }
 
 // Context functions
 EXPORT void* my_pa_context_new(x64emu_t* emu, my_pa_mainloop_api_t* mainloop, void* name)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     if(mainloop==my_mainloop_ref) mainloop=my_mainloop_orig;    // need native version
     return my->pa_context_new(mainloop, name);
 }
 
 EXPORT void* my_pa_context_new_with_proplist(x64emu_t* emu, my_pa_mainloop_api_t* mainloop, void* name, void* proplist)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     if(mainloop==my_mainloop_ref) mainloop=my_mainloop_orig;    // need native version
     return my->pa_context_new_with_proplist(mainloop, name, proplist);
 }
 
 EXPORT int my_pa_signal_init(x64emu_t* emu, my_pa_mainloop_api_t* mainloop)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     if(mainloop==my_mainloop_ref) mainloop=my_mainloop_orig;    // need native version
     return my->pa_signal_init(mainloop);
 }
 
 EXPORT void* my_pa_signal_new(x64emu_t* emu, int sig, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_signal_new(sig, find_signal_Fct(cb), data);
 }
 
 EXPORT void my_pa_signal_set_destroy(x64emu_t* emu, void* e, void* cb)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_signal_set_destroy(e, find_signal_destroy_Fct(cb));
 }
 
@@ -1122,7 +1081,6 @@ typedef struct my_pa_spawn_api_s {
 
 EXPORT int my_pa_context_connect(x64emu_t* emu, void* context, void* server, int flags, my_pa_spawn_api_t* api)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     if(!api) {
         return my->pa_context_connect(context, server, flags, api);
     }
@@ -1137,186 +1095,155 @@ EXPORT int my_pa_context_connect(x64emu_t* emu, void* context, void* server, int
 
 EXPORT void my_pa_context_set_state_callback(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_state_callback(context, find_state_context_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_default_sink(x64emu_t* emu, void* context, void* name, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_default_sink(context, name, find_success_context_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_default_source(x64emu_t* emu, void* context, void* name, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_default_source(context, name, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_move_sink_input_by_index(x64emu_t* emu, void* context, uint32_t idx, uint32_t sink_idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_move_sink_input_by_index(context, idx, sink_idx, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_module_info_list(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_module_info_list(context, find_module_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_server_info(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_server_info(context, find_server_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_client_info_list(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_client_info_list(context, find_client_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_sink_input_info(x64emu_t* emu, void* context, uint32_t idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_sink_input_info(context, idx, find_module_info_Fct(cb), data);
 }
 EXPORT void* my_pa_context_get_sink_input_info_list(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_sink_input_info_list(context, find_module_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_sink_info_list(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_sink_info_list(context, find_module_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_sink_info_by_name(x64emu_t* emu, void* context, void* name, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_sink_info_by_name(context, name, find_module_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_source_info_list(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_source_info_list(context, find_module_info_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_sink_input_mute(x64emu_t* emu, void* context, uint32_t idx, int mute, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_sink_input_mute(context, idx, mute, find_success_context_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_sink_input_volume(x64emu_t* emu, void* context, uint32_t idx, void* volume, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_sink_input_volume(context, idx, volume, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_sink_info_by_index(x64emu_t* emu, void* context, uint32_t idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_sink_info_by_index(context, idx, find_module_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_source_info_by_index(x64emu_t* emu, void* context, uint32_t idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_source_info_by_index(context, idx, find_module_info_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_source_volume_by_index(x64emu_t* emu, void* context, uint32_t idx, void* volume, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_source_volume_by_index(context, idx, volume, find_success_context_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_source_mute_by_index(x64emu_t* emu, void* context, uint32_t idx, int mute, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_source_mute_by_index(context, idx, mute, find_success_context_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_sink_volume_by_index(x64emu_t* emu, void* context, uint32_t idx, void* volume, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_sink_volume_by_index(context, idx, volume, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_unload_module(x64emu_t* emu, void* context, uint32_t idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_unload_module(context, idx, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_load_module(x64emu_t* emu, void* context, void* name, void* arg, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_load_module(context, name, arg, find_context_index_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_subscribe(x64emu_t* emu, void* context, uint32_t m, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_subscribe(context, m, find_success_context_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_subscribe_callback(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_set_subscribe_callback(context, find_subscribe_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_drain(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_drain(context, find_notify_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_exit_daemon(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_exit_daemon(context, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_proplist_remove(x64emu_t* emu, void* context, void* keys, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_proplist_remove(context, keys, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_proplist_update(x64emu_t* emu, void* context, int mode, void* p, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_proplist_update(context, mode, p, find_success_context_Fct(cb), data);
 }
 
 EXPORT void my_pa_context_set_event_callback(x64emu_t* emu, void* context, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_context_set_event_callback(context, find_event_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_set_name(x64emu_t* emu, void* context, void* name, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_set_name(context, name, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_set_source_volume_by_name(x64emu_t* emu, void* context, void* name,void* volume, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_set_source_volume_by_name(context, name, volume, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_source_info_by_name(x64emu_t* emu, void* context, void* name, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_source_info_by_name(context, name, find_module_info_Fct(cb), data);
 }
 
@@ -1324,25 +1251,21 @@ EXPORT void* my_pa_context_get_source_info_by_name(x64emu_t* emu, void* context,
 
 EXPORT void* my_pa_stream_drain(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_drain(stream, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_flush(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_flush(stream, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_latency_update_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_latency_update_callback(stream, find_stream_notify_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_read_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_read_callback(stream, find_stream_request_Fct(cb), data);
 }
 
@@ -1350,7 +1273,6 @@ EXPORT int my_pa_stream_write(x64emu_t* emu, void* stream, void* d, size_t nbyte
 {
     if(!emu->context->pulse)
         return 0;
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     if(!my)
         return 0;
     return my->pa_stream_write(stream, d, nbytes, findFreeFct(cb), offset, seek);
@@ -1358,115 +1280,96 @@ EXPORT int my_pa_stream_write(x64emu_t* emu, void* stream, void* d, size_t nbyte
 
 EXPORT void* my_pa_stream_update_timing_info(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_update_timing_info(stream, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_prebuf(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_prebuf(stream, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_proplist_remove(x64emu_t* emu, void* stream, void* keys, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_proplist_remove(stream, keys, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_proplist_update(x64emu_t* emu, void* stream, int32_t mode, void* p, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_proplist_update(stream, mode, p, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_set_buffer_attr(x64emu_t* emu, void* stream, void* attr, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_set_buffer_attr(stream, attr, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_buffer_attr_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_buffer_attr_callback(stream, find_stream_notify_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_event_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_event_callback(stream, find_stream_event_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_moved_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_moved_callback(stream, find_stream_notify_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_set_name(x64emu_t* emu, void* stream, void* name, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_set_name(stream, name, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_overflow_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_overflow_callback(stream, find_stream_notify_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_started_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_started_callback(stream, find_stream_notify_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_state_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_state_callback(stream, find_stream_state_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_suspended_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_suspended_callback(stream, find_stream_notify_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_underflow_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_underflow_callback(stream, find_stream_notify_Fct(cb), data);
 }
 
 EXPORT void my_pa_stream_set_write_callback(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     my->pa_stream_set_write_callback(stream, find_stream_request_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_trigger(x64emu_t* emu, void* stream, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_trigger(stream, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_update_sample_rate(x64emu_t* emu, void* stream, uint32_t rate, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_update_sample_rate(stream, rate, find_stream_success_Fct(cb), data);
 }
 
 EXPORT void* my_pa_stream_cork(x64emu_t* emu, void* stream, int32_t b, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_stream_cork(stream, b, find_stream_success_Fct(cb), data);
 }
 
 EXPORT int my_pa_proplist_setf(x64emu_t* emu, void* p, void* key, void* fmt, uint64_t* b)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     char* format;
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 3);
     PREPARE_VALIST;
@@ -1479,7 +1382,6 @@ EXPORT int my_pa_proplist_setf(x64emu_t* emu, void* p, void* key, void* fmt, uin
 
 EXPORT void my_pa_mainloop_set_poll_func(x64emu_t* emu, void* m, void* f, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
 
     my->pa_mainloop_set_poll_func(m, find_poll_Fct(f), data);
 }
@@ -1487,7 +1389,6 @@ EXPORT void my_pa_mainloop_set_poll_func(x64emu_t* emu, void* m, void* f, void*
 #if 0
 EXPORT void my_pa_log_level_meta(x64emu_t* emu, int level, void* file, int line, void* func, void* format, void* b, va_list V)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     #ifndef NOALIGN
     // need to align on arm
     myStackAlign((const char*)format, b, emu->scratch);
@@ -1501,97 +1402,81 @@ EXPORT void my_pa_log_level_meta(x64emu_t* emu, int level, void* file, int line,
 
 EXPORT void* my_pa_ext_device_restore_save_formats(x64emu_t* emu, void* c, int t, uint32_t idx, uint8_t n, void* f, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_ext_device_restore_save_formats(c, t, idx, n, f, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_ext_device_restore_read_formats(x64emu_t* emu, void* c, int t, uint32_t idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_ext_device_restore_read_formats(c, t, idx, find_device_restore_read_device_formats_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_set_source_port_by_index(x64emu_t* emu, void* c, uint32_t idx, void* p, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_set_source_port_by_index(c, idx, p, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_set_card_profile_by_index(x64emu_t* emu, void* c, uint32_t idx, void* p, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_set_card_profile_by_index(c, idx, p, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_set_sink_port_by_index(x64emu_t* emu, void* c, uint32_t idx, void* p, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_set_sink_port_by_index(c, idx, p, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_card_info_list(x64emu_t* emu, void* c, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_card_info_list(c, find_card_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_source_output_info_list(x64emu_t* emu, void* c, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_source_output_info_list(c, find_source_output_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_ext_device_restore_read_formats_all(x64emu_t* emu, void* c, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_ext_device_restore_read_formats_all(c, find_device_restore_read_device_formats_Fct(cb), data);
 }
 
 EXPORT void* my_pa_ext_device_restore_set_subscribe_cb(x64emu_t* emu, void* c, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_ext_device_restore_set_subscribe_cb(c, find_device_restore_subscribe_Fct(cb), data);
 }
 
 EXPORT void* my_pa_ext_device_restore_subscribe(x64emu_t* emu, void* c, int e, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_ext_device_restore_subscribe(c, e, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_set_sink_mute_by_index(x64emu_t* emu, void* c, uint32_t idx, int m, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_set_sink_mute_by_index(c, idx, m, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_set_sink_port_by_name(x64emu_t* emu, void* c, void* n, void* p, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_set_sink_port_by_name(c, n, p, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_move_source_output_by_index(x64emu_t* emu, void* c, uint32_t idx, uint32_t s, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_move_source_output_by_index(c, idx, s, find_success_context_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_card_info_by_index(x64emu_t* emu, void* c, uint32_t idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_card_info_by_index(c, idx, find_card_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_client_info(x64emu_t* emu, void* c, uint32_t idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_client_info(c, idx, find_client_info_Fct(cb), data);
 }
 
 EXPORT void* my_pa_context_get_source_output_info(x64emu_t* emu, void* c, uint32_t idx, void* cb, void* data)
 {
-    pulse_my_t* my = (pulse_my_t*)emu->context->pulse->priv.w.p2;
     return my->pa_context_get_source_output_info(c, idx, find_source_output_info_Fct(cb), data);
 }
 #define PRE_INIT        \
@@ -1599,13 +1484,12 @@ EXPORT void* my_pa_context_get_source_output_info(x64emu_t* emu, void* c, uint32
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getPulseMy(lib);   \
-    box64->pulse = lib;                 \
+    getMy(lib);     \
+    box64->pulse = lib;
 
 
 #define CUSTOM_FINI \
     lib->context->pulse = NULL;     \
-    freePulseMy(lib->priv.w.p2);    \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedpulsesimple.c b/src/wrapped/wrappedpulsesimple.c
index 57d1d3b0..165f3f29 100755
--- a/src/wrapped/wrappedpulsesimple.c
+++ b/src/wrapped/wrappedpulsesimple.c
@@ -25,9 +25,7 @@ const char* pulsesimpleName = "libpulse-simple.so.0";
         return -1;
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libpulse.so.0"); \
+    setNeededLibs(&lib->priv.w, 1, "libpulse.so.0");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedsdl1.c b/src/wrapped/wrappedsdl1.c
index 34d41708..f57c4376 100755
--- a/src/wrapped/wrappedsdl1.c
+++ b/src/wrapped/wrappedsdl1.c
@@ -52,13 +52,7 @@ typedef void  (*vFv_t)();
     GO(SDL_FreeRW, sdl1_freerw)
 #include "generated/wrappedsdl1types.h"
 
-typedef struct sdl1_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} sdl1_my_t;
+#include "wrappercallback.h"
 
 // event filter. Needs to be global, but there is only one, so that's should be fine
 x64emu_t        *sdl1_evtfilter = NULL;
@@ -66,24 +60,6 @@ void*           sdl1_evtfnc = NULL;
 int             sdl1_evtautofree = 0;
 int             sdl1_evtinside = 0;
 
-
-void* getSDL1My(library_t* lib)
-{
-    sdl1_my_t* my = (sdl1_my_t*)calloc(1, sizeof(sdl1_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-
-    return my;
-}
-#undef SUPER
-
-void freeSDL1My(void* lib)
-{
-    (void)lib;
-    //sdl1_my_t *my = (sdl1_my_t *)lib;
-}
-
 #define SUPER() \
 GO(0)   \
 GO(1)   \
@@ -174,7 +150,6 @@ static void* reverse_EvtFilterFct(void* fct)
 EXPORT int my_SDL_OpenAudio(x64emu_t* emu, void* d, void* o)
 {
     SDL_AudioSpec *desired = (SDL_AudioSpec*)d;
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     // create a callback
     void *fnc = (void*)desired->callback;
     desired->callback = find_AudioCallback_Fct(desired->callback);
@@ -192,7 +167,6 @@ EXPORT int my_SDL_OpenAudio(x64emu_t* emu, void* d, void* o)
 
 EXPORT void *my_SDL_LoadBMP_RW(x64emu_t* emu, void* a, int b)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->SDL_LoadBMP_RW(rw, b);
     if(b==0)
@@ -201,7 +175,6 @@ EXPORT void *my_SDL_LoadBMP_RW(x64emu_t* emu, void* a, int b)
 }
 EXPORT int32_t my_SDL_SaveBMP_RW(x64emu_t* emu, void* a, void* b, int c)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     int32_t r = my->SDL_SaveBMP_RW(rw, b, c);
     if(c==0)
@@ -210,7 +183,6 @@ EXPORT int32_t my_SDL_SaveBMP_RW(x64emu_t* emu, void* a, void* b, int c)
 }
 EXPORT void *my_SDL_LoadWAV_RW(x64emu_t* emu, void* a, int b, void* c, void* d, void* e)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->SDL_LoadWAV_RW(rw, b, c, d, e);
     if(b==0)
@@ -219,7 +191,6 @@ EXPORT void *my_SDL_LoadWAV_RW(x64emu_t* emu, void* a, int b, void* c, void* d,
 }
 EXPORT uint32_t my_SDL_ReadBE16(x64emu_t* emu, void* a)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_ReadBE16(rw);
     RWNativeEnd(rw);
@@ -227,7 +198,6 @@ EXPORT uint32_t my_SDL_ReadBE16(x64emu_t* emu, void* a)
 }
 EXPORT uint32_t my_SDL_ReadBE32(x64emu_t* emu, void* a)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_ReadBE32(rw);
     RWNativeEnd(rw);
@@ -235,7 +205,6 @@ EXPORT uint32_t my_SDL_ReadBE32(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my_SDL_ReadBE64(x64emu_t* emu, void* a)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint64_t r = my->SDL_ReadBE64(rw);
     RWNativeEnd(rw);
@@ -243,7 +212,6 @@ EXPORT uint64_t my_SDL_ReadBE64(x64emu_t* emu, void* a)
 }
 EXPORT uint32_t my_SDL_ReadLE16(x64emu_t* emu, void* a)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_ReadLE16(rw);
     RWNativeEnd(rw);
@@ -251,7 +219,6 @@ EXPORT uint32_t my_SDL_ReadLE16(x64emu_t* emu, void* a)
 }
 EXPORT uint32_t my_SDL_ReadLE32(x64emu_t* emu, void* a)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_ReadLE32(rw);
     RWNativeEnd(rw);
@@ -259,7 +226,6 @@ EXPORT uint32_t my_SDL_ReadLE32(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my_SDL_ReadLE64(x64emu_t* emu, void* a)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint64_t r = my->SDL_ReadLE64(rw);
     RWNativeEnd(rw);
@@ -267,7 +233,6 @@ EXPORT uint64_t my_SDL_ReadLE64(x64emu_t* emu, void* a)
 }
 EXPORT uint32_t my_SDL_WriteBE16(x64emu_t* emu, void* a, uint16_t v)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_WriteBE16(rw, v);
     RWNativeEnd(rw);
@@ -275,7 +240,6 @@ EXPORT uint32_t my_SDL_WriteBE16(x64emu_t* emu, void* a, uint16_t v)
 }
 EXPORT uint32_t my_SDL_WriteBE32(x64emu_t* emu, void* a, uint32_t v)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_WriteBE32(rw, v);
     RWNativeEnd(rw);
@@ -283,7 +247,6 @@ EXPORT uint32_t my_SDL_WriteBE32(x64emu_t* emu, void* a, uint32_t v)
 }
 EXPORT uint32_t my_SDL_WriteBE64(x64emu_t* emu, void* a, uint64_t v)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_WriteBE64(rw, v);
     RWNativeEnd(rw);
@@ -291,7 +254,6 @@ EXPORT uint32_t my_SDL_WriteBE64(x64emu_t* emu, void* a, uint64_t v)
 }
 EXPORT uint32_t my_SDL_WriteLE16(x64emu_t* emu, void* a, uint16_t v)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_WriteLE16(rw, v);
     RWNativeEnd(rw);
@@ -299,7 +261,6 @@ EXPORT uint32_t my_SDL_WriteLE16(x64emu_t* emu, void* a, uint16_t v)
 }
 EXPORT uint32_t my_SDL_WriteLE32(x64emu_t* emu, void* a, uint32_t v)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_WriteLE32(rw, v);
     RWNativeEnd(rw);
@@ -307,7 +268,6 @@ EXPORT uint32_t my_SDL_WriteLE32(x64emu_t* emu, void* a, uint32_t v)
 }
 EXPORT uint32_t my_SDL_WriteLE64(x64emu_t* emu, void* a, uint64_t v)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     uint32_t r = my->SDL_WriteLE64(rw, v);
     RWNativeEnd(rw);
@@ -317,28 +277,24 @@ EXPORT uint32_t my_SDL_WriteLE64(x64emu_t* emu, void* a, uint64_t v)
 // SDL1 doesn't really used rw_ops->type, but box64 does, so set sensible value (from SDL2)....
 EXPORT void *my_SDL_RWFromConstMem(x64emu_t* emu, void* a, int b)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* r = (SDL1_RWops_t*)my->SDL_RWFromConstMem(a, b);
     RWSetType(r, 5);
     return AddNativeRW(emu, r);
 }
 EXPORT void *my_SDL_RWFromFP(x64emu_t* emu, void* a, int b)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* r = (SDL1_RWops_t*)my->SDL_RWFromFP(a, b);
     RWSetType(r, 2);
     return AddNativeRW(emu, r);
 }
 EXPORT void *my_SDL_RWFromFile(x64emu_t* emu, void* a, void* b)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* r = (SDL1_RWops_t*)my->SDL_RWFromFile(a, b);
     RWSetType(r, 2);
     return AddNativeRW(emu, r);
 }
 EXPORT void *my_SDL_RWFromMem(x64emu_t* emu, void* a, int b)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     SDL1_RWops_t* r = (SDL1_RWops_t*)my->SDL_RWFromMem(a, b);
     RWSetType(r, 4);
     return AddNativeRW(emu, r);
@@ -346,19 +302,16 @@ EXPORT void *my_SDL_RWFromMem(x64emu_t* emu, void* a, int b)
 
 EXPORT void *my_SDL_AddTimer(x64emu_t* emu, uint32_t a, void* cb, void* p)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     return my->SDL_AddTimer(a, find_TimerCallback_Fct(cb), p);
 }
 
 EXPORT int my_SDL_RemoveTimer(x64emu_t* emu, void *t)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     return my->SDL_RemoveTimer(t);
 }
 
 EXPORT int32_t my_SDL_SetTimer(x64emu_t* emu, uint32_t t, void* p)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     return my->SDL_SetTimer(t, find_TimerCallback_Fct(p));
 }
 #if 0
@@ -378,18 +331,15 @@ EXPORT int32_t my_SDL_ConvertAudio(x64emu_t* emu, void* a)
 #endif
 EXPORT void my_SDL_SetEventFilter(x64emu_t* emu, void* a)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     my->SDL_SetEventFilter(find_EvtFilter_Fct(a));
 }
 EXPORT void *my_SDL_GetEventFilter(x64emu_t* emu)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     return reverse_EvtFilterFct(my->SDL_GetEventFilter());
 }
 
 EXPORT void *my_SDL_CreateThread(x64emu_t* emu, void* cb, void* p)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     void* et = NULL;
     void* fnc = my_prepare_thread(emu, cb, p, 0, &et);
     return my->SDL_CreateThread(fnc, et);
@@ -397,7 +347,6 @@ EXPORT void *my_SDL_CreateThread(x64emu_t* emu, void* cb, void* p)
 
 EXPORT void my_SDL_KillThread(x64emu_t* emu, void* p)
 {
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     my->SDL_KillThread(p);
 }
 
@@ -407,7 +356,6 @@ EXPORT void* my_SDL_GL_GetProcAddress(x64emu_t* emu, void* name)
     khint_t k;
     const char* rname = (const char*)name;
     printf_log(LOG_DEBUG, "Calling SDL_GL_GetProcAddress(%s)\n", rname);
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     // check if glxprocaddress is filled, and search for lib and fill it if needed
     if(!emu->context->glwrappers)
         fillGLProcWrapper(emu->context);
@@ -496,7 +444,6 @@ typedef struct {
 EXPORT int32_t my_SDL_GetWMInfo(x64emu_t* emu, void* p)
 {
     // does SDL_SysWMinfo needs alignment?
-    sdl1_my_t *my = (sdl1_my_t *)emu->context->sdl1lib->priv.w.p2;
     int ret = my->SDL_GetWMInfo(p);
     my_SDL_SysWMinfo *info = (my_SDL_SysWMinfo*)p;
     if(info->info.x11.lock_func)
@@ -507,20 +454,18 @@ EXPORT int32_t my_SDL_GetWMInfo(x64emu_t* emu, void* p)
 }
 
 #define CUSTOM_INIT \
-    box64->sdl1lib = lib; \
-    lib->priv.w.p2 = getSDL1My(lib); \
-    box64->sdl1allocrw = ((sdl1_my_t*)lib->priv.w.p2)->SDL_AllocRW; \
-    box64->sdl1freerw  = ((sdl1_my_t*)lib->priv.w.p2)->SDL_FreeRW; \
-    lib->priv.w.needed = 3; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libm.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libdl.so.2"); \
-    lib->priv.w.neededlibs[2] = strdup("librt.so.1");
+    box64->sdl1lib = lib;                   \
+    getMy(lib);                             \
+    box64->sdl1allocrw = my->SDL_AllocRW;   \
+    box64->sdl1freerw  = my->SDL_FreeRW;    \
+    setNeededLibs(&lib->priv.w, 3,          \
+        "libm.so.6",                        \
+        "libdl.so.2",                       \
+        "librt.so.1");
 
 #define CUSTOM_FINI \
-    ((sdl1_my_t *)lib->priv.w.p2)->SDL_Quit();              \
-    freeSDL1My(lib->priv.w.p2);                             \
-    free(lib->priv.w.p2);                                   \
+    my->SDL_Quit();                                         \
+    freeMy();                                               \
     ((box64context_t*)(lib->context))->sdl1lib = NULL;      \
     ((box64context_t*)(lib->context))->sdl1allocrw = NULL;  \
     ((box64context_t*)(lib->context))->sdl1freerw = NULL;
diff --git a/src/wrapped/wrappedsdl1image.c b/src/wrapped/wrappedsdl1image.c
index 34d240c6..f4569773 100755
--- a/src/wrapped/wrappedsdl1image.c
+++ b/src/wrapped/wrappedsdl1image.c
@@ -15,61 +15,18 @@
 #include "box64context.h"
 #include "sdl1rwops.h"
 
-typedef void* (*pFpi_t)(void*, int32_t);
-typedef void* (*pFp_t)(void*);
-typedef void* (*pFpip_t)(void*, int32_t, void*);
+const char* sdl1imageName = "libSDL_image-1.2.so.0";
+#define LIBNAME sdl1image
 
-typedef struct sdl1image_my_s {
-    pFp_t       IMG_LoadBMP_RW;
-    pFp_t       IMG_LoadCUR_RW;
-    pFp_t       IMG_LoadGIF_RW;
-    pFp_t       IMG_LoadICO_RW;
-    pFp_t       IMG_LoadJPG_RW;
-    pFp_t       IMG_LoadLBM_RW;
-    pFp_t       IMG_LoadPCX_RW;
-    pFp_t       IMG_LoadPNG_RW;
-    pFp_t       IMG_LoadPNM_RW;
-    pFp_t       IMG_LoadTGA_RW;
-    pFp_t       IMG_LoadTIF_RW;
-    pFpip_t     IMG_LoadTyped_RW;
-    pFp_t       IMG_LoadWEBP_RW;
-    pFp_t       IMG_LoadXCF_RW;
-    pFp_t       IMG_LoadXPM_RW;
-    pFp_t       IMG_LoadXV_RW;
-    pFpi_t      IMG_Load_RW;
-} sdl1image_my_t;
+#define ADDED_FUNCTIONS()           \
 
-static library_t* my_lib = NULL;
+#include "generated/wrappedsdl1imagetypes.h"
 
-static void* getSDL1ImageMy(library_t* lib)
-{
-    sdl1image_my_t* my = (sdl1image_my_t*)calloc(1, sizeof(sdl1image_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    GO(IMG_LoadBMP_RW,pFp_t)
-    GO(IMG_LoadCUR_RW,pFp_t)
-    GO(IMG_LoadGIF_RW,pFp_t)
-    GO(IMG_LoadICO_RW,pFp_t)
-    GO(IMG_LoadJPG_RW,pFp_t)
-    GO(IMG_LoadLBM_RW,pFp_t)
-    GO(IMG_LoadPCX_RW,pFp_t)
-    GO(IMG_LoadPNG_RW,pFp_t)
-    GO(IMG_LoadPNM_RW,pFp_t)
-    GO(IMG_LoadTGA_RW,pFp_t)
-    GO(IMG_LoadTIF_RW,pFp_t)
-    GO(IMG_LoadTyped_RW,pFpip_t)
-    GO(IMG_LoadWEBP_RW,pFp_t)
-    GO(IMG_LoadXCF_RW,pFp_t)
-    GO(IMG_LoadXPM_RW,pFp_t)
-    GO(IMG_LoadXV_RW,pFp_t)
-    GO(IMG_Load_RW,pFpi_t)
-    #undef GO
-    return my;
-}
+#include "wrappercallback.h"
 
 #define GO(A) \
 void EXPORT *my_##A(x64emu_t* emu, void* a) \
 { \
-    sdl1image_my_t *my = (sdl1image_my_t *)my_lib->priv.w.p2; \
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a); \
     void* r = my->A(rw); \
     RWNativeEnd(rw); \
@@ -94,7 +51,6 @@ GO(IMG_LoadXV_RW)
 
 void EXPORT *my_IMG_LoadTyped_RW(x64emu_t* emu, void* a, int32_t b, void* c)
 {
-    sdl1image_my_t *my = (sdl1image_my_t *)my_lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->IMG_LoadTyped_RW(rw, b, c);
     if(b==0)
@@ -103,7 +59,6 @@ void EXPORT *my_IMG_LoadTyped_RW(x64emu_t* emu, void* a, int32_t b, void* c)
 }
 void EXPORT *my_IMG_Load_RW(x64emu_t* emu, void* a, int32_t b)
 {
-    sdl1image_my_t *my = (sdl1image_my_t *)my_lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->IMG_Load_RW(rw, b);
     if(b==0)
@@ -111,20 +66,12 @@ void EXPORT *my_IMG_Load_RW(x64emu_t* emu, void* a, int32_t b)
     return r;
 }
 
-const char* sdl1imageName = "libSDL_image-1.2.so.0";
-#define LIBNAME sdl1image
-
 #define CUSTOM_INIT \
-    my_lib = lib; \
-    lib->priv.w.p2 = getSDL1ImageMy(lib);   \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libSDL-1.2.so.0");                      \
-    lib->priv.w.neededlibs[1] = strdup("libz.so.1");
+    getMy(lib);   \
+    setNeededLibs(&lib->priv.w, 2, "libSDL-1.2.so.0", "libz.so.1");
 
 #define CUSTOM_FINI \
-    free(lib->priv.w.p2); \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedsdl1mixer.c b/src/wrapped/wrappedsdl1mixer.c
index 760f0f05..6f1a5ff2 100755
--- a/src/wrapped/wrappedsdl1mixer.c
+++ b/src/wrapped/wrappedsdl1mixer.c
@@ -16,40 +16,14 @@
 #include "sdl1rwops.h"
 #include "callback.h"
 
-typedef void* (*pFpi_t)(void*, int32_t);
-typedef void* (*pFp_t)(void*);
-typedef int   (*iFip_t)(int, void*);
-typedef void* (*pFpii_t)(void*, int32_t, int32_t);
-typedef void  (*vFp_t)(void*);
-typedef void  (*vFpp_t)(void*, void*);
-typedef int   (*iFippp_t)(int, void*, void*, void*);
+const char* sdl1mixerName = "libSDL_mixer-1.2.so.0";
+#define LIBNAME sdl1mixer
 
-#define SUPER() \
-    GO(Mix_LoadMUSType_RW,pFpii_t)      \
-    GO(Mix_LoadMUS_RW,pFp_t)            \
-    GO(Mix_LoadWAV_RW,pFpi_t)           \
-    GO(Mix_SetPostMix,vFpp_t)           \
-    GO(Mix_ChannelFinished,vFp_t)       \
-    GO(Mix_HookMusic, vFpp_t)           \
-    GO(Mix_HookMusicFinished, vFp_t)    \
-    GO(Mix_RegisterEffect, iFippp_t)    \
-    GO(Mix_UnregisterEffect, iFip_t)    \
+#define ADDED_FUNCTIONS() \
 
-typedef struct sdl1mixer_my_s {
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} sdl1mixer_my_t;
+#include "generated/wrappedsdl1mixertypes.h"
 
-static void* getSDL1MixerMy(library_t* lib)
-{
-    sdl1mixer_my_t* my = (sdl1mixer_my_t*)calloc(1, sizeof(sdl1mixer_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -188,7 +162,6 @@ static void freeSDL1MixerMy(library_t* lib)
 
 EXPORT void* my_Mix_LoadMUSType_RW(x64emu_t* emu, void* a, int32_t b, int32_t c)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->Mix_LoadMUSType_RW(rw, b, c);
     if(c==0)
@@ -197,7 +170,6 @@ EXPORT void* my_Mix_LoadMUSType_RW(x64emu_t* emu, void* a, int32_t b, int32_t c)
 }
 EXPORT void* my_Mix_LoadMUS_RW(x64emu_t* emu, void* a)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->Mix_LoadMUS_RW(rw);
     RWNativeEnd(rw);  // this one never free the RWops
@@ -205,7 +177,6 @@ EXPORT void* my_Mix_LoadMUS_RW(x64emu_t* emu, void* a)
 }
 EXPORT void* my_Mix_LoadWAV_RW(x64emu_t* emu, void* a, int32_t b)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->Mix_LoadWAV_RW(rw, b);
     if(b==0)
@@ -215,50 +186,40 @@ EXPORT void* my_Mix_LoadWAV_RW(x64emu_t* emu, void* a, int32_t b)
 
 EXPORT void my_Mix_SetPostMix(x64emu_t* emu, void* a, void* b)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     my->Mix_SetPostMix(find_MixFunc_Fct(a), b);
 }
 
 EXPORT void my_Mix_ChannelFinished(x64emu_t* emu, void* cb)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     my->Mix_ChannelFinished(find_ChannelFinished_Fct(cb));
 }
 
 EXPORT void my_Mix_HookMusic(x64emu_t* emu, void* f, void* arg)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     my->Mix_HookMusic(find_MixFunc_Fct(f), arg);
 }
 
 EXPORT void my_Mix_HookMusicFinished(x64emu_t* emu, void* f)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     my->Mix_HookMusicFinished(find_MusicFinished_Fct(f));
 }
 
 EXPORT int my_Mix_RegisterEffect(x64emu_t* emu, int chan, void* f, void* d, void *arg)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     return my->Mix_RegisterEffect(chan, find_EffectFunc_Fct(f), find_EffectDone_Fct(d), arg);
 }
 
 EXPORT int my_Mix_UnregisterEffect(x64emu_t* emu, int channel, void* f)
 {
-    sdl1mixer_my_t *my = (sdl1mixer_my_t *)emu->context->sdl1mixerlib->priv.w.p2;
     return my->Mix_UnregisterEffect(channel, find_EffectFunc_Fct(f));
 }
 
-const char* sdl1mixerName = "libSDL_mixer-1.2.so.0";
-#define LIBNAME sdl1mixer
-
 #define CUSTOM_INIT \
     box64->sdl1mixerlib = lib; \
-    lib->priv.w.p2 = getSDL1MixerMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeSDL1MixerMy(lib); \
-    free(lib->priv.w.p2); \
+    freeMy();       \
     ((box64context_t*)(lib->context))->sdl1mixerlib = NULL;
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedsdl1net.c b/src/wrapped/wrappedsdl1net.c
index f69cfaee..ee16dbe7 100755
--- a/src/wrapped/wrappedsdl1net.c
+++ b/src/wrapped/wrappedsdl1net.c
@@ -16,31 +16,12 @@
 #include "sdl1rwops.h"
 
 
-typedef struct sdl1net_my_s {
-} sdl1net_my_t;
-
-static void* getSDL1NetMy(library_t* lib)
-{
-    sdl1net_my_t* my = (sdl1net_my_t*)calloc(1, sizeof(sdl1net_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    #undef GO
-    return my;
-}
-
-static library_t* my_lib = NULL;
-
-
 const char* sdl1netName = "libSDL_net-1.2.so.0";
 #define LIBNAME sdl1net
 
-#define CUSTOM_INIT                     \
-    my_lib = lib;                       \
-    lib->altmy = strdup("my_");        \
-    lib->priv.w.p2 = getSDL1NetMy(lib);
+#define CUSTOM_INIT \
+    SETALT(my_);
 
-#define CUSTOM_FINI                     \
-    free(lib->priv.w.p2);               \
-    my_lib = NULL;
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedsdl1sound.c b/src/wrapped/wrappedsdl1sound.c
index d68ab641..b82bd482 100755
--- a/src/wrapped/wrappedsdl1sound.c
+++ b/src/wrapped/wrappedsdl1sound.c
@@ -20,26 +20,10 @@ const char* sdl1soundName = "libSDL_sound-1.0.so.1";
 
 #include "generated/wrappedsdl1soundtypes.h"
 
-typedef struct sdl1sound_my_s {
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} sdl1sound_my_t;
-
-static library_t* my_lib = NULL;
-
-static void* getSDL1SoundMy(library_t* lib)
-{
-    sdl1sound_my_t* my = (sdl1sound_my_t*)calloc(1, sizeof(sdl1sound_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
+#include "wrappercallback.h"
 
 EXPORT void* my_Sound_NewSample(x64emu_t* emu, void* a, void* ext, void* desired, uint32_t buffersize)
 {
-    sdl1sound_my_t *my = (sdl1sound_my_t *)my_lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->Sound_NewSample(rw, ext, desired, buffersize);
     //RWNativeEnd(rw);  // will be closed automatically
@@ -47,15 +31,11 @@ EXPORT void* my_Sound_NewSample(x64emu_t* emu, void* a, void* ext, void* desired
 }
 
 #define CUSTOM_INIT \
-    my_lib = lib; \
-    lib->priv.w.p2 = getSDL1SoundMy(lib);   \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libSDL-1.2.so.0");
+    getMy(lib);   \
+    setNeededLibs(&lib->priv.w, 1, "libSDL-1.2.so.0");
 
 #define CUSTOM_FINI \
-    free(lib->priv.w.p2); \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedsdl1ttf.c b/src/wrapped/wrappedsdl1ttf.c
index 721fac9b..d0bb80c0 100755
--- a/src/wrapped/wrappedsdl1ttf.c
+++ b/src/wrapped/wrappedsdl1ttf.c
@@ -15,29 +15,17 @@
 #include "box64context.h"
 #include "sdl1rwops.h"
 
-typedef void* (*pFpii_t)(void*, int32_t, int32_t);
-typedef void* (*pFpiii_t)(void*, int32_t, int32_t, int32_t);
+const char* sdl1ttfName = "libSDL_ttf-2.0.so.0";
+#define LIBNAME sdl1ttf
 
-typedef struct sdl1ttf_my_s {
-    pFpii_t     TTF_OpenFontRW;
-    pFpiii_t    TTF_OpenFontIndexRW;
-} sdl1ttf_my_t;
+#define ADDED_FUNCTIONS()           \
 
-static library_t* my_lib = NULL;
+#include "generated/wrappedsdl1ttftypes.h"
 
-static void* getSDL1TTFMy(library_t* lib)
-{
-    sdl1ttf_my_t* my = (sdl1ttf_my_t*)calloc(1, sizeof(sdl1ttf_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    GO(TTF_OpenFontIndexRW,pFpiii_t)
-    GO(TTF_OpenFontRW, pFpii_t)
-    #undef GO
-    return my;
-}
+#include "wrappercallback.h"
 
 void EXPORT *my_TTF_OpenFontIndexRW(x64emu_t* emu, void* a, int32_t b, int32_t c, int32_t d)
 {
-    sdl1ttf_my_t *my = (sdl1ttf_my_t *)my_lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->TTF_OpenFontIndexRW(rw, b, c, d);
     if(b==0)
@@ -47,7 +35,6 @@ void EXPORT *my_TTF_OpenFontIndexRW(x64emu_t* emu, void* a, int32_t b, int32_t c
 
 void EXPORT *my_TTF_OpenFontRW(x64emu_t* emu, void* a, int32_t b, int32_t c)
 {
-    sdl1ttf_my_t *my = (sdl1ttf_my_t *)my_lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)a);
     void* r = my->TTF_OpenFontRW(rw, b, c);
     if(b==0)
@@ -55,16 +42,11 @@ void EXPORT *my_TTF_OpenFontRW(x64emu_t* emu, void* a, int32_t b, int32_t c)
     return r;
 }
 
-const char* sdl1ttfName = "libSDL_ttf-2.0.so.0";
-#define LIBNAME sdl1ttf
-
 #define CUSTOM_INIT \
-    my_lib = lib; \
-    lib->priv.w.p2 = getSDL1TTFMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    free(lib->priv.w.p2); \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedsdl2.c b/src/wrapped/wrappedsdl2.c
index 5416b52b..a8c81937 100755
--- a/src/wrapped/wrappedsdl2.c
+++ b/src/wrapped/wrappedsdl2.c
@@ -87,27 +87,7 @@ typedef void  (*vFiupV_t)(int64_t, uint64_t, void*, va_list);
     GO(SDL_LogMessageV, vFiupV_t)
 #include "generated/wrappedsdl2types.h"
 
-typedef struct sdl2_my_s {
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} sdl2_my_t;
-
-void* getSDL2My(library_t* lib)
-{
-    sdl2_my_t* my = (sdl2_my_t*)calloc(1, sizeof(sdl2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeSDL2My(void* lib)
-{
-    (void)lib;
-    //sdl2_my_t *my = (sdl2_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -239,7 +219,6 @@ EXPORT int64_t my2_SDL_OpenAudio(x64emu_t* emu, void* d, void* o)
 {
     SDL2_AudioSpec *desired = (SDL2_AudioSpec*)d;
 
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // create a callback
     void *fnc = (void*)desired->callback;
     desired->callback = find_AudioCallback_Fct(fnc);
@@ -259,7 +238,6 @@ EXPORT int64_t my2_SDL_OpenAudioDevice(x64emu_t* emu, void* device, int64_t isca
 {
     SDL2_AudioSpec *desired = (SDL2_AudioSpec*)d;
 
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // create a callback
     void *fnc = (void*)desired->callback;
     desired->callback = find_AudioCallback_Fct(fnc);
@@ -277,7 +255,6 @@ EXPORT int64_t my2_SDL_OpenAudioDevice(x64emu_t* emu, void* device, int64_t isca
 
 EXPORT void *my2_SDL_LoadFile_RW(x64emu_t* emu, void* a, void* b, int c)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->SDL_LoadFile_RW(rw, b, c);
     if(c==0)
@@ -286,7 +263,6 @@ EXPORT void *my2_SDL_LoadFile_RW(x64emu_t* emu, void* a, void* b, int c)
 }
 EXPORT void *my2_SDL_LoadBMP_RW(x64emu_t* emu, void* a, int b)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->SDL_LoadBMP_RW(rw, b);
     if(b==0)
@@ -295,7 +271,6 @@ EXPORT void *my2_SDL_LoadBMP_RW(x64emu_t* emu, void* a, int b)
 }
 EXPORT int64_t my2_SDL_SaveBMP_RW(x64emu_t* emu, void* a, void* b, int c)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     int64_t r = my->SDL_SaveBMP_RW(rw, b, c);
     if(c==0)
@@ -304,7 +279,6 @@ EXPORT int64_t my2_SDL_SaveBMP_RW(x64emu_t* emu, void* a, void* b, int c)
 }
 EXPORT void *my2_SDL_LoadWAV_RW(x64emu_t* emu, void* a, int b, void* c, void* d, void* e)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->SDL_LoadWAV_RW(rw, b, c, d, e);
     if(b==0)
@@ -313,7 +287,6 @@ EXPORT void *my2_SDL_LoadWAV_RW(x64emu_t* emu, void* a, int b, void* c, void* d,
 }
 EXPORT int64_t my2_SDL_GameControllerAddMappingsFromRW(x64emu_t* emu, void* a, int b)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     int64_t r = my->SDL_GameControllerAddMappingsFromRW(rw, b);
     if(b==0)
@@ -322,7 +295,6 @@ EXPORT int64_t my2_SDL_GameControllerAddMappingsFromRW(x64emu_t* emu, void* a, i
 }
 EXPORT uint64_t my2_SDL_ReadU8(x64emu_t* emu, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_ReadU8(rw);
     RWNativeEnd2(rw);
@@ -330,7 +302,6 @@ EXPORT uint64_t my2_SDL_ReadU8(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my2_SDL_ReadBE16(x64emu_t* emu, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_ReadBE16(rw);
     RWNativeEnd2(rw);
@@ -338,7 +309,6 @@ EXPORT uint64_t my2_SDL_ReadBE16(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my2_SDL_ReadBE32(x64emu_t* emu, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_ReadBE32(rw);
     RWNativeEnd2(rw);
@@ -346,7 +316,6 @@ EXPORT uint64_t my2_SDL_ReadBE32(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my2_SDL_ReadBE64(x64emu_t* emu, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_ReadBE64(rw);
     RWNativeEnd2(rw);
@@ -354,7 +323,6 @@ EXPORT uint64_t my2_SDL_ReadBE64(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my2_SDL_ReadLE16(x64emu_t* emu, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_ReadLE16(rw);
     RWNativeEnd2(rw);
@@ -362,7 +330,6 @@ EXPORT uint64_t my2_SDL_ReadLE16(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my2_SDL_ReadLE32(x64emu_t* emu, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_ReadLE32(rw);
     RWNativeEnd2(rw);
@@ -370,7 +337,6 @@ EXPORT uint64_t my2_SDL_ReadLE32(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my2_SDL_ReadLE64(x64emu_t* emu, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_ReadLE64(rw);
     RWNativeEnd2(rw);
@@ -378,7 +344,6 @@ EXPORT uint64_t my2_SDL_ReadLE64(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my2_SDL_WriteU8(x64emu_t* emu, void* a, uint8_t v)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_WriteU8(rw, v);
     RWNativeEnd2(rw);
@@ -386,7 +351,6 @@ EXPORT uint64_t my2_SDL_WriteU8(x64emu_t* emu, void* a, uint8_t v)
 }
 EXPORT uint64_t my2_SDL_WriteBE16(x64emu_t* emu, void* a, uint16_t v)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_WriteBE16(rw, v);
     RWNativeEnd2(rw);
@@ -394,7 +358,6 @@ EXPORT uint64_t my2_SDL_WriteBE16(x64emu_t* emu, void* a, uint16_t v)
 }
 EXPORT uint64_t my2_SDL_WriteBE32(x64emu_t* emu, void* a, uint64_t v)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_WriteBE32(rw, v);
     RWNativeEnd2(rw);
@@ -402,7 +365,6 @@ EXPORT uint64_t my2_SDL_WriteBE32(x64emu_t* emu, void* a, uint64_t v)
 }
 EXPORT uint64_t my2_SDL_WriteBE64(x64emu_t* emu, void* a, uint64_t v)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_WriteBE64(rw, v);
     RWNativeEnd2(rw);
@@ -410,7 +372,6 @@ EXPORT uint64_t my2_SDL_WriteBE64(x64emu_t* emu, void* a, uint64_t v)
 }
 EXPORT uint64_t my2_SDL_WriteLE16(x64emu_t* emu, void* a, uint16_t v)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_WriteLE16(rw, v);
     RWNativeEnd2(rw);
@@ -418,7 +379,6 @@ EXPORT uint64_t my2_SDL_WriteLE16(x64emu_t* emu, void* a, uint16_t v)
 }
 EXPORT uint64_t my2_SDL_WriteLE32(x64emu_t* emu, void* a, uint64_t v)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_WriteLE32(rw, v);
     RWNativeEnd2(rw);
@@ -426,7 +386,6 @@ EXPORT uint64_t my2_SDL_WriteLE32(x64emu_t* emu, void* a, uint64_t v)
 }
 EXPORT uint64_t my2_SDL_WriteLE64(x64emu_t* emu, void* a, uint64_t v)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t r = my->SDL_WriteLE64(rw, v);
     RWNativeEnd2(rw);
@@ -435,25 +394,21 @@ EXPORT uint64_t my2_SDL_WriteLE64(x64emu_t* emu, void* a, uint64_t v)
 
 EXPORT void *my2_SDL_RWFromConstMem(x64emu_t* emu, void* a, int b)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     void* r = my->SDL_RWFromConstMem(a, b);
     return AddNativeRW2(emu, (SDL2_RWops_t*)r);
 }
 EXPORT void *my2_SDL_RWFromFP(x64emu_t* emu, void* a, int b)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     void* r = my->SDL_RWFromFP(a, b);
     return AddNativeRW2(emu, (SDL2_RWops_t*)r);
 }
 EXPORT void *my2_SDL_RWFromFile(x64emu_t* emu, void* a, void* b)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     void* r = my->SDL_RWFromFile(a, b);
     return AddNativeRW2(emu, (SDL2_RWops_t*)r);
 }
 EXPORT void *my2_SDL_RWFromMem(x64emu_t* emu, void* a, int b)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     void* r = my->SDL_RWFromMem(a, b);
     return AddNativeRW2(emu, (SDL2_RWops_t*)r);
 }
@@ -468,7 +423,6 @@ EXPORT int64_t my2_SDL_RWseek(x64emu_t* emu, void* a, int64_t offset, int64_t wh
 }
 EXPORT int64_t my2_SDL_RWtell(x64emu_t* emu, void* a)
 {
-    //sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     int64_t ret = RWNativeSeek2(rw, 0, 1);  //1 == RW_SEEK_CUR
     RWNativeEnd2(rw);
@@ -476,7 +430,6 @@ EXPORT int64_t my2_SDL_RWtell(x64emu_t* emu, void* a)
 }
 EXPORT uint64_t my2_SDL_RWread(x64emu_t* emu, void* a, void* ptr, uint64_t size, uint64_t maxnum)
 {
-    //sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t ret = RWNativeRead2(rw, ptr, size, maxnum);
     RWNativeEnd2(rw);
@@ -484,7 +437,6 @@ EXPORT uint64_t my2_SDL_RWread(x64emu_t* emu, void* a, void* ptr, uint64_t size,
 }
 EXPORT uint64_t my2_SDL_RWwrite(x64emu_t* emu, void* a, const void* ptr, uint64_t size, uint64_t maxnum)
 {
-    //sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     uint64_t ret = RWNativeWrite2(rw, ptr, size, maxnum);
     RWNativeEnd2(rw);
@@ -499,7 +451,6 @@ EXPORT int my2_SDL_RWclose(x64emu_t* emu, void* a)
 
 EXPORT int my2_SDL_SaveAllDollarTemplates(x64emu_t* emu, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     int ret = my->SDL_SaveAllDollarTemplates(rw);
     RWNativeEnd2(rw);
@@ -508,7 +459,6 @@ EXPORT int my2_SDL_SaveAllDollarTemplates(x64emu_t* emu, void* a)
 
 EXPORT int my2_SDL_SaveDollarTemplate(x64emu_t* emu, int gesture, void* a)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     int ret = my->SDL_SaveDollarTemplate(gesture, rw);
     RWNativeEnd2(rw);
@@ -517,24 +467,20 @@ EXPORT int my2_SDL_SaveDollarTemplate(x64emu_t* emu, int gesture, void* a)
 
 EXPORT void *my2_SDL_AddTimer(x64emu_t* emu, uint64_t a, void* f, void* p)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     return my->SDL_AddTimer(a, find_Timer_Fct(f), p);
 }
 
 EXPORT int my2_SDL_RemoveTimer(x64emu_t* emu, void* t)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     return my->SDL_RemoveTimer(t);
 }
 
 EXPORT void my2_SDL_SetEventFilter(x64emu_t* emu, void* p, void* userdata)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     my->SDL_SetEventFilter(find_eventfilter_Fct(p), userdata);
 }
 EXPORT int my2_SDL_GetEventFilter(x64emu_t* emu, void** f, void* userdata)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     int ret = my->SDL_GetEventFilter(f, userdata);
     *f = reverse_eventfilter_Fct(*f);
     return ret;
@@ -542,14 +488,12 @@ EXPORT int my2_SDL_GetEventFilter(x64emu_t* emu, void** f, void* userdata)
 
 EXPORT void my2_SDL_LogGetOutputFunction(x64emu_t* emu, void** f, void* arg)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
 
     my->SDL_LogGetOutputFunction(f, arg);
     if(*f) *f = reverse_LogOutput_Fct(*f);
 }
 EXPORT void my2_SDL_LogSetOutputFunction(x64emu_t* emu, void* f, void* arg)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
 
     my->SDL_LogSetOutputFunction(find_LogOutput_Fct(f), arg);
 }
@@ -569,8 +513,6 @@ EXPORT int my2_SDL_vsnprintf(x64emu_t* emu, void* buff, size_t s, void * fmt, x6
 
 EXPORT void* my2_SDL_CreateThread(x64emu_t* emu, void* f, void* n, void* p)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
     void* et = NULL;
     void* fnc = my_prepare_thread(emu, f, p, 0, &et);
     return my->SDL_CreateThread(fnc, n, et);
@@ -591,7 +533,6 @@ char EXPORT *my2_SDL_GetBasePath(x64emu_t* emu) {
 }
 
 EXPORT void my2_SDL_LogCritical(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // SDL_LOG_PRIORITY_CRITICAL == 6
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
@@ -599,7 +540,6 @@ EXPORT void my2_SDL_LogCritical(x64emu_t* emu, int64_t cat, void* fmt, void *b)
 }
 
 EXPORT void my2_SDL_LogError(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // SDL_LOG_PRIORITY_ERROR == 5
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
@@ -607,7 +547,6 @@ EXPORT void my2_SDL_LogError(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
 }
 
 EXPORT void my2_SDL_LogWarn(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // SDL_LOG_PRIORITY_WARN == 4
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
@@ -615,7 +554,6 @@ EXPORT void my2_SDL_LogWarn(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
 }
 
 EXPORT void my2_SDL_LogInfo(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // SDL_LOG_PRIORITY_INFO == 3
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
@@ -623,7 +561,6 @@ EXPORT void my2_SDL_LogInfo(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
 }
 
 EXPORT void my2_SDL_LogDebug(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // SDL_LOG_PRIORITY_DEBUG == 2
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
@@ -631,7 +568,6 @@ EXPORT void my2_SDL_LogDebug(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
 }
 
 EXPORT void my2_SDL_LogVerbose(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // SDL_LOG_PRIORITY_VERBOSE == 1
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 2);
     PREPARE_VALIST;
@@ -639,7 +575,6 @@ EXPORT void my2_SDL_LogVerbose(x64emu_t* emu, int64_t cat, void* fmt, void *b) {
 }
 
 EXPORT void my2_SDL_Log(x64emu_t* emu, void* fmt, void *b) {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // SDL_LOG_PRIORITY_INFO == 3
     // SDL_LOG_CATEGORY_APPLICATION == 0
     myStackAlign(emu, (const char*)fmt, b, emu->scratch, R_EAX, 1);
@@ -654,7 +589,6 @@ EXPORT void* my2_SDL_GL_GetProcAddress(x64emu_t* emu, void* name)
     khint_t k;
     const char* rname = (const char*)name;
     if(dlsym_error && box64_log<LOG_DEBUG) printf_log(LOG_NONE, "Calling SDL_GL_GetProcAddress(%s) => ", rname);
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     // check if glxprocaddress is filled, and search for lib and fill it if needed
     if(!emu->context->glxprocaddress)
         emu->context->glxprocaddress = (procaddess_t)my->SDL_GL_GetProcAddress;
@@ -756,8 +690,6 @@ static const sdl2_tls_dtor dtor_cb[nb_once] = {
 };
 EXPORT int64_t my2_SDL_TLSSet(x64emu_t* emu, uint64_t id, void* value, void* dtor)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
 	if(!dtor)
 		return my->SDL_TLSSet(id, value, NULL);
 	int n = 0;
@@ -775,12 +707,10 @@ EXPORT int64_t my2_SDL_TLSSet(x64emu_t* emu, uint64_t id, void* value, void* dto
 
 EXPORT void my2_SDL_AddEventWatch(x64emu_t* emu, void* p, void* userdata)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     my->SDL_AddEventWatch(find_eventfilter_Fct(p), userdata);
 }
 EXPORT void my2_SDL_DelEventWatch(x64emu_t* emu, void* p, void* userdata)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
     my->SDL_DelEventWatch(find_eventfilter_Fct(p), userdata);
 }
 
@@ -799,8 +729,6 @@ EXPORT void* my2_SDL_LoadFunction(x64emu_t* emu, void* handle, void* name)
 
 EXPORT int64_t my2_SDL_IsJoystickPS4(x64emu_t* emu, uint16_t vendor, uint16_t product_id)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
     if(my->SDL_IsJoystickPS4)
         return my->SDL_IsJoystickPS4(vendor, product_id);
     // fallback
@@ -808,8 +736,6 @@ EXPORT int64_t my2_SDL_IsJoystickPS4(x64emu_t* emu, uint16_t vendor, uint16_t pr
 }
 EXPORT int64_t my2_SDL_IsJoystickNintendoSwitchPro(x64emu_t* emu, uint16_t vendor, uint16_t product_id)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
     if(my->SDL_IsJoystickNintendoSwitchPro)
         return my->SDL_IsJoystickNintendoSwitchPro(vendor, product_id);
     // fallback
@@ -817,8 +743,6 @@ EXPORT int64_t my2_SDL_IsJoystickNintendoSwitchPro(x64emu_t* emu, uint16_t vendo
 }
 EXPORT int64_t my2_SDL_IsJoystickSteamController(x64emu_t* emu, uint16_t vendor, uint16_t product_id)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
     if(my->SDL_IsJoystickSteamController)
         return my->SDL_IsJoystickSteamController(vendor, product_id);
     // fallback
@@ -826,8 +750,6 @@ EXPORT int64_t my2_SDL_IsJoystickSteamController(x64emu_t* emu, uint16_t vendor,
 }
 EXPORT int64_t my2_SDL_IsJoystickXbox360(x64emu_t* emu, uint16_t vendor, uint16_t product_id)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
     if(my->SDL_IsJoystickXbox360)
         return my->SDL_IsJoystickXbox360(vendor, product_id);
     // fallback
@@ -835,8 +757,6 @@ EXPORT int64_t my2_SDL_IsJoystickXbox360(x64emu_t* emu, uint16_t vendor, uint16_
 }
 EXPORT int64_t my2_SDL_IsJoystickXboxOne(x64emu_t* emu, uint16_t vendor, uint16_t product_id)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
     if(my->SDL_IsJoystickXboxOne)
         return my->SDL_IsJoystickXboxOne(vendor, product_id);
     // fallback
@@ -844,8 +764,6 @@ EXPORT int64_t my2_SDL_IsJoystickXboxOne(x64emu_t* emu, uint16_t vendor, uint16_
 }
 EXPORT int64_t my2_SDL_IsJoystickXInput(x64emu_t* emu, uint64_t a, uint64_t b)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
     if(my->SDL_IsJoystickXInput)
         return my->SDL_IsJoystickXInput(a, b);
     // fallback
@@ -853,8 +771,6 @@ EXPORT int64_t my2_SDL_IsJoystickXInput(x64emu_t* emu, uint64_t a, uint64_t b)
 }
 EXPORT int64_t my2_SDL_IsJoystickHIDAPI(x64emu_t* emu, uint64_t a, uint64_t b)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-
     if(my->SDL_IsJoystickHIDAPI)
         return my->SDL_IsJoystickHIDAPI(a, b);
     // fallback
@@ -864,8 +780,6 @@ EXPORT int64_t my2_SDL_IsJoystickHIDAPI(x64emu_t* emu, uint64_t a, uint64_t b)
 void* my_vkGetInstanceProcAddr(x64emu_t* emu, void* device, void* name);
 EXPORT void* my2_SDL_Vulkan_GetVkGetInstanceProcAddr(x64emu_t* emu)
 {
-    sdl2_my_t *my = (sdl2_my_t *)emu->context->sdl2lib->priv.w.p2;
-    
     if(!emu->context->vkprocaddress)
         emu->context->vkprocaddress = (vkprocaddess_t)my->SDL_Vulkan_GetVkGetInstanceProcAddr();
 
@@ -876,8 +790,6 @@ EXPORT void* my2_SDL_Vulkan_GetVkGetInstanceProcAddr(x64emu_t* emu)
 
 EXPORT void my2_SDL_GetJoystickGUIDInfo(SDL_JoystickGUID guid, uint16_t *vend, uint16_t *prod, uint16_t *ver)
 {
-    sdl2_my_t *my = (sdl2_my_t *)my_context->sdl2lib->priv.w.p2;
-
     if(my->SDL_GetJoystickGUIDInfo)
         my->SDL_GetJoystickGUIDInfo(guid, vend, prod, ver);
     // fallback
@@ -897,24 +809,22 @@ EXPORT void my2_SDL_GetJoystickGUIDInfo(SDL_JoystickGUID guid, uint16_t *vend, u
 }
 
 #define CUSTOM_INIT \
-    box64->sdl2lib = lib;                                           \
-    lib->priv.w.p2 = getSDL2My(lib);                                \
-    box64->sdl2allocrw = ((sdl2_my_t*)lib->priv.w.p2)->SDL_AllocRW; \
-    box64->sdl2freerw  = ((sdl2_my_t*)lib->priv.w.p2)->SDL_FreeRW;  \
-    lib->altmy = strdup("my2_");                                    \
-    lib->priv.w.needed = 4;                                         \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libdl.so.2");               \
-    lib->priv.w.neededlibs[1] = strdup("libm.so.6");                \
-    lib->priv.w.neededlibs[2] = strdup("librt.so.1");               \
-    lib->priv.w.neededlibs[3] = strdup("libpthread.so.0");
+    box64->sdl2lib = lib;                   \
+    getMy(lib);                             \
+    box64->sdl2allocrw = my->SDL_AllocRW;   \
+    box64->sdl2freerw  = my->SDL_FreeRW;    \
+    SETALT(my2_);                           \
+    setNeededLibs(&lib->priv.w, 4,          \
+        "libdl.so.2",                       \
+        "libm.so.6",                        \
+        "librt.so.1",                       \
+        "libpthread.so.0");
 
 #define CUSTOM_FINI \
-    ((sdl2_my_t *)lib->priv.w.p2)->SDL_Quit();                  \
+    my->SDL_Quit();                                             \
     if(my_glhandle) my_dlclose(thread_get_emu(), my_glhandle);  \
     my_glhandle = NULL;                                         \
-    freeSDL2My(lib->priv.w.p2);                                 \
-    free(lib->priv.w.p2);                                       \
+    freeMy();                                                   \
     ((box64context_t*)(lib->context))->sdl2lib = NULL;          \
     ((box64context_t*)(lib->context))->sdl2allocrw = NULL;      \
     ((box64context_t*)(lib->context))->sdl2freerw = NULL;
diff --git a/src/wrapped/wrappedsdl2image.c b/src/wrapped/wrappedsdl2image.c
index eae0c159..f99e00fb 100755
--- a/src/wrapped/wrappedsdl2image.c
+++ b/src/wrapped/wrappedsdl2image.c
@@ -15,70 +15,18 @@
 #include "box64context.h"
 #include "sdl2rwops.h"
 
-typedef void* (*pFpi_t)(void*, int32_t);
-typedef void* (*pFp_t)(void*);
-typedef void* (*pFpip_t)(void*, int32_t, void*);
-typedef void* (*pFppi_t)(void*, void*, int32_t);
-typedef int32_t (*iFppi_t)(void*, void*, int32_t);
-typedef void* (*pFppip_t)(void*, void*, int32_t, void*);
+const char* sdl2imageName = "libSDL2_image-2.0.so.0";
+#define LIBNAME sdl2image
 
-typedef struct sdl2image_my_s {
-    pFp_t       IMG_LoadBMP_RW;
-    pFp_t       IMG_LoadCUR_RW;
-    pFp_t       IMG_LoadGIF_RW;
-    pFp_t       IMG_LoadICO_RW;
-    pFp_t       IMG_LoadJPG_RW;
-    pFp_t       IMG_LoadLBM_RW;
-    pFp_t       IMG_LoadPCX_RW;
-    pFp_t       IMG_LoadPNG_RW;
-    pFp_t       IMG_LoadPNM_RW;
-    pFp_t       IMG_LoadTGA_RW;
-    pFp_t       IMG_LoadTIF_RW;
-    pFpip_t     IMG_LoadTyped_RW;
-    pFp_t       IMG_LoadWEBP_RW;
-    pFp_t       IMG_LoadXCF_RW;
-    pFp_t       IMG_LoadXPM_RW;
-    pFp_t       IMG_LoadXV_RW;
-    pFpi_t      IMG_Load_RW;
-    iFppi_t     IMG_SavePNG_RW;
-    pFppi_t     IMG_LoadTexture_RW;
-    pFppip_t    IMG_LoadTextureTyped_RW;
-} sdl2image_my_t;
+#define ADDED_FUNCTIONS()           \
 
-static library_t* my_lib = NULL;
+#include "generated/wrappedsdl2imagetypes.h"
 
-static void* getSDL2ImageMy(library_t* lib)
-{
-    sdl2image_my_t* my = (sdl2image_my_t*)calloc(1, sizeof(sdl2image_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    GO(IMG_LoadBMP_RW,pFp_t)
-    GO(IMG_LoadCUR_RW,pFp_t)
-    GO(IMG_LoadGIF_RW,pFp_t)
-    GO(IMG_LoadICO_RW,pFp_t)
-    GO(IMG_LoadJPG_RW,pFp_t)
-    GO(IMG_LoadLBM_RW,pFp_t)
-    GO(IMG_LoadPCX_RW,pFp_t)
-    GO(IMG_LoadPNG_RW,pFp_t)
-    GO(IMG_LoadPNM_RW,pFp_t)
-    GO(IMG_LoadTGA_RW,pFp_t)
-    GO(IMG_LoadTIF_RW,pFp_t)
-    GO(IMG_LoadTyped_RW,pFpip_t)
-    GO(IMG_LoadWEBP_RW,pFp_t)
-    GO(IMG_LoadXCF_RW,pFp_t)
-    GO(IMG_LoadXPM_RW,pFp_t)
-    GO(IMG_LoadXV_RW,pFp_t)
-    GO(IMG_Load_RW,pFpi_t)
-    GO(IMG_SavePNG_RW, iFppi_t)
-    GO(IMG_LoadTexture_RW, pFppi_t)
-    GO(IMG_LoadTextureTyped_RW, pFppip_t)
-    #undef GO
-    return my;
-}
+#include "wrappercallback.h"
 
 #define GO(A) \
 EXPORT void *my2_##A(x64emu_t* emu, void* a) \
 { \
-    sdl2image_my_t *my = (sdl2image_my_t *)my_lib->priv.w.p2; \
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a); \
     void* r = my->A(rw); \
     RWNativeEnd2(rw); \
@@ -103,7 +51,6 @@ GO(IMG_LoadXV_RW)
 
  EXPORT void *my2_IMG_LoadTyped_RW(x64emu_t* emu, void* a, int32_t b, void* c)
 {
-    sdl2image_my_t *my = (sdl2image_my_t *)my_lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->IMG_LoadTyped_RW(rw, b, c);
     if(b==0)
@@ -112,7 +59,6 @@ GO(IMG_LoadXV_RW)
 }
 EXPORT void *my2_IMG_Load_RW(x64emu_t* emu, void* a, int32_t b)
 {
-    sdl2image_my_t *my = (sdl2image_my_t *)my_lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->IMG_Load_RW(rw, b);
     if(b==0)
@@ -121,7 +67,6 @@ EXPORT void *my2_IMG_Load_RW(x64emu_t* emu, void* a, int32_t b)
 }
 EXPORT int32_t my2_IMG_SavePNG_RW(x64emu_t* emu, void* s, void* a, int32_t b)
 {
-    sdl2image_my_t *my = (sdl2image_my_t *)my_lib->priv.w.p2;
     // some old? fuction signature use IMG_SavePNG_RW(dst, surf, compression) instead of the IMG_SavePNG_RW(surf, dst, freedst)
     // need to try detect if s is in fact a RWops
     int32_t r;
@@ -140,7 +85,6 @@ EXPORT int32_t my2_IMG_SavePNG_RW(x64emu_t* emu, void* s, void* a, int32_t b)
 
 EXPORT void* my2_IMG_LoadTexture_RW(x64emu_t* emu, void* rend, void* a, int32_t b)
 {
-    sdl2image_my_t *my = (sdl2image_my_t *)my_lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->IMG_LoadTexture_RW(rend, rw, b);
     if(b==0)
@@ -150,7 +94,6 @@ EXPORT void* my2_IMG_LoadTexture_RW(x64emu_t* emu, void* rend, void* a, int32_t
 
 EXPORT void* my2_IMG_LoadTextureTyped_RW(x64emu_t* emu, void* rend, void* a, int32_t b, void* type)
 {
-    sdl2image_my_t *my = (sdl2image_my_t *)my_lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->IMG_LoadTextureTyped_RW(rend, rw, b, type);
     if(b==0)
@@ -158,20 +101,13 @@ EXPORT void* my2_IMG_LoadTextureTyped_RW(x64emu_t* emu, void* rend, void* a, int
     return r;
 }
 
-const char* sdl2imageName = "libSDL2_image-2.0.so.0";
-#define LIBNAME sdl2image
-
 #define CUSTOM_INIT \
-    my_lib = lib; \
-    lib->priv.w.p2 = getSDL2ImageMy(lib);   \
-    lib->altmy = strdup("my2_");            \
-    lib->priv.w.needed = 1; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libSDL2-2.0.so.0");
+    getMy(lib);     \
+    SETALT(my2_);   \
+    setNeededLibs(&lib->priv.w, 1, "libSDL2-2.0.so.0");
 
 #define CUSTOM_FINI \
-    free(lib->priv.w.p2); \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedsdl2mixer.c b/src/wrapped/wrappedsdl2mixer.c
index df4fc67f..c0c5af5f 100755
--- a/src/wrapped/wrappedsdl2mixer.c
+++ b/src/wrapped/wrappedsdl2mixer.c
@@ -16,50 +16,17 @@
 #include "sdl2rwops.h"
 #include "callback.h"
 
-typedef void* (*pFpi_t)(void*, int32_t);
-typedef int32_t(*iFip_t)(int32_t, void*);
-typedef void* (*pFpii_t)(void*, int32_t, int32_t);
-typedef void  (*vFpp_t)(void*, void*);
-typedef void  (*vFp_t)(void*);
-typedef int32_t (*iFippp_t)(int32_t, void*, void*, void*);
-typedef int   (*iFiwC_t)(int, int16_t, uint8_t);
-
-#define SUPER() \
-    GO(Mix_LoadMUSType_RW,pFpii_t)      \
-    GO(Mix_LoadMUS_RW,pFpi_t)           \
-    GO(Mix_LoadWAV_RW,pFpi_t)           \
-    GO(Mix_SetPostMix,vFpp_t)           \
-    GO(Mix_RegisterEffect, iFippp_t)    \
-    GO(Mix_UnregisterEffect, iFip_t)    \
-    GO(Mix_ChannelFinished,vFp_t)       \
-    GO(Mix_HookMusic, vFpp_t)           \
-    GO(Mix_HookMusicFinished, vFp_t)    \
-    GO(Mix_SetPosition, iFiwC_t)        \
-
-typedef struct sdl2mixer_my_s {
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
+const char* sdl2mixerName = "libSDL2_mixer-2.0.so.0";
+#define LIBNAME sdl2mixer
 
-    x64emu_t* PostCallback;
-    x64emu_t* hookMusicCB;
-} sdl2mixer_my_t;
+typedef int (*iFiwC_t)(int, int16_t, uint8_t);
 
-static void* getSDL2MixerMy(library_t* lib)
-{
-    sdl2mixer_my_t* my = (sdl2mixer_my_t*)calloc(1, sizeof(sdl2mixer_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
+#define ADDED_FUNCTIONS() \
+    GO(Mix_SetPosition, iFiwC_t)
 
-    return my;
-}
+#include "generated/wrappedsdl2mixertypes.h"
 
-static void freeSDL2MixerMy(library_t* lib)
-{
-    (void)lib;
-    //sdl2mixer_my_t *my = lib->priv.w.p2;
-}
+#include "wrappercallback.h"
 
 #undef SUPER
 
@@ -194,7 +161,6 @@ static void* find_MusicFinished_Fct(void* fct)
 
 EXPORT void* my2_Mix_LoadMUSType_RW(x64emu_t* emu, void* a, int32_t b, int32_t c)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->Mix_LoadMUSType_RW(rw, b, c);
     if(c==0)
@@ -203,7 +169,6 @@ EXPORT void* my2_Mix_LoadMUSType_RW(x64emu_t* emu, void* a, int32_t b, int32_t c
 }
 EXPORT void* my2_Mix_LoadMUS_RW(x64emu_t* emu, void* a, int32_t f)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->Mix_LoadMUS_RW(rw, f);
     if(f==0)
@@ -212,7 +177,6 @@ EXPORT void* my2_Mix_LoadMUS_RW(x64emu_t* emu, void* a, int32_t f)
 }
 EXPORT void* my2_Mix_LoadWAV_RW(x64emu_t* emu, void* a, int32_t f)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->Mix_LoadWAV_RW(rw, f);
     if(f==0)
@@ -222,41 +186,35 @@ EXPORT void* my2_Mix_LoadWAV_RW(x64emu_t* emu, void* a, int32_t f)
 
 EXPORT void my2_Mix_SetPostMix(x64emu_t* emu, void* a, void* b)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
     my->Mix_SetPostMix(find_MixFunc_Fct(a), b);
 }
 
 EXPORT int32_t my2_Mix_RegisterEffect(x64emu_t*emu, int32_t channel, void* cb_effect, void* cb_done, void* arg)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
 
     return my->Mix_RegisterEffect(channel, find_EffectFunc_Fct(cb_effect), find_EffectDone_Fct(cb_done), arg);
 }
 
 EXPORT int32_t my2_Mix_UnregisterEffect(x64emu_t* emu, int channel, void* f)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
 
     return my->Mix_UnregisterEffect(channel, find_EffectFunc_Fct(f));
 }
 
 EXPORT void my2_Mix_ChannelFinished(x64emu_t* emu, void* cb)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
 
     my->Mix_ChannelFinished(find_ChannelFinished_Fct(cb));
 }
 
 EXPORT void my2_Mix_HookMusic(x64emu_t* emu, void* f, void* arg)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
 
     my->Mix_HookMusic(find_MixFunc_Fct(f), arg);
 }
 
 EXPORT void my2_Mix_HookMusicFinished(x64emu_t* emu, void* f)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
 
     my->Mix_HookMusicFinished(find_MusicFinished_Fct(f));
 }
@@ -264,21 +222,16 @@ EXPORT void my2_Mix_HookMusicFinished(x64emu_t* emu, void* f)
 // This is a hack for AntiChamber
 EXPORT int my2_MinorityMix_SetPosition(x64emu_t* emu, int channel, int16_t angle)
 {
-    sdl2mixer_my_t *my = (sdl2mixer_my_t *)emu->context->sdl2mixerlib->priv.w.p2;
     return my->Mix_SetPosition(channel, angle, 0);
 }
 
-const char* sdl2mixerName = "libSDL2_mixer-2.0.so.0";
-#define LIBNAME sdl2mixer
-
 #define CUSTOM_INIT \
     box64->sdl2mixerlib = lib; \
-    lib->priv.w.p2 = getSDL2MixerMy(lib); \
-    lib->altmy = strdup("my2_");
+    getMy(lib); \
+    SETALT(my2_);
 
 #define CUSTOM_FINI \
-    freeSDL2MixerMy(lib); \
-    free(lib->priv.w.p2); \
+    freeMy();       \
     ((box64context_t*)(lib->context))->sdl2mixerlib = NULL;
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedsdl2net.c b/src/wrapped/wrappedsdl2net.c
index ead8d048..7009e4b7 100755
--- a/src/wrapped/wrappedsdl2net.c
+++ b/src/wrapped/wrappedsdl2net.c
@@ -16,31 +16,10 @@
 #include "sdl2rwops.h"
 
 
-typedef struct sdl2net_my_s {
-} sdl2net_my_t;
-
-static void* getSDL2NetMy(library_t* lib)
-{
-    sdl2net_my_t* my = (sdl2net_my_t*)calloc(1, sizeof(sdl2net_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    (void)lib; // So many wrapped functions here
-    #undef GO
-    return my;
-}
-
-static library_t* my_lib = NULL;
-
-
 const char* sdl2netName = "libSDL2_net-2.0.so.0";
 #define LIBNAME sdl2net
 
-#define CUSTOM_INIT                     \
-    my_lib = lib;                       \
-    lib->altmy = strdup("my2_");        \
-    lib->priv.w.p2 = getSDL2NetMy(lib);
-
-#define CUSTOM_FINI                     \
-    free(lib->priv.w.p2);               \
-    my_lib = NULL;
+#define CUSTOM_INIT      \
+    SETALT(my2_);        \
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedsdl2ttf.c b/src/wrapped/wrappedsdl2ttf.c
index c0944858..ff1afeb8 100755
--- a/src/wrapped/wrappedsdl2ttf.c
+++ b/src/wrapped/wrappedsdl2ttf.c
@@ -15,29 +15,17 @@
 #include "box64context.h"
 #include "sdl2rwops.h"
 
-typedef void* (*pFpii_t)(void*, int32_t, int32_t);
-typedef void* (*pFpiii_t)(void*, int32_t, int32_t, int32_t);
+const char* sdl2ttfName = "libSDL2_ttf-2.0.so.0";
+#define LIBNAME sdl2ttf
 
-typedef struct sdl2ttf_my_s {
-    pFpii_t     TTF_OpenFontRW;
-    pFpiii_t    TTF_OpenFontIndexRW;
-} sdl2ttf_my_t;
+#define ADDED_FUNCTIONS()           \
 
-static void* getSDL2TTFMy(library_t* lib)
-{
-    sdl2ttf_my_t* my = (sdl2ttf_my_t*)calloc(1, sizeof(sdl2ttf_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    GO(TTF_OpenFontIndexRW,pFpiii_t)
-    GO(TTF_OpenFontRW, pFpii_t)
-    #undef GO
-    return my;
-}
+#include "generated/wrappedsdl2ttftypes.h"
 
-static library_t* my_lib = NULL;
+#include "wrappercallback.h"
 
 void EXPORT *my2_TTF_OpenFontIndexRW(x64emu_t* emu, void* a, int32_t b, int32_t c, int32_t d)
 {
-    sdl2ttf_my_t *my = (sdl2ttf_my_t *)my_lib->priv.w.p2;
     SDL2_RWops_t* rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->TTF_OpenFontIndexRW(rw, b, c, d);
     if(b==0)
@@ -47,7 +35,6 @@ void EXPORT *my2_TTF_OpenFontIndexRW(x64emu_t* emu, void* a, int32_t b, int32_t
 
 void EXPORT *my2_TTF_OpenFontRW(x64emu_t* emu, void* a, int32_t b, int32_t c)
 {
-    sdl2ttf_my_t *my = (sdl2ttf_my_t *)my_lib->priv.w.p2;
     SDL2_RWops_t* rw = RWNativeStart2(emu, (SDL2_RWops_t*)a);
     void* r = my->TTF_OpenFontRW(rw, b, c);
     if(b==0)
@@ -55,20 +42,13 @@ void EXPORT *my2_TTF_OpenFontRW(x64emu_t* emu, void* a, int32_t b, int32_t c)
     return r;
 }
 
-const char* sdl2ttfName = "libSDL2_ttf-2.0.so.0";
-#define LIBNAME sdl2ttf
-
 #define CUSTOM_INIT                     \
-    my_lib = lib;                       \
-    lib->altmy = strdup("my2_");        \
-    lib->priv.w.p2 = getSDL2TTFMy(lib); \
-    lib->priv.w.needed = 1;             \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libSDL2-2.0.so.0");
+    SETALT(my2_);                       \
+    getMy(lib);                         \
+    setNeededLibs(&lib->priv.w, 1, "libSDL2-2.0.so.0");
 
 #define CUSTOM_FINI                     \
-    free(lib->priv.w.p2);               \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedsmime3.c b/src/wrapped/wrappedsmime3.c
index 78ddf017..a9eea343 100755
--- a/src/wrapped/wrappedsmime3.c
+++ b/src/wrapped/wrappedsmime3.c
@@ -20,31 +20,10 @@
 
 const char* smime3Name = "libsmime3.so";
 #define LIBNAME smime3
-static library_t *my_lib = NULL;
 
 #include "generated/wrappedsmime3types.h"
 
-typedef struct smime3_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} smime3_my_t;
-
-void* getSmime3My(library_t* lib)
-{
-    my_lib = lib;
-    smime3_my_t* my = (smime3_my_t*)calloc(1, sizeof(smime3_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-void freeSmime3My(void* lib)
-{
-    //smime3_my_t *my = (smime3_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #undef SUPER
 
@@ -266,31 +245,23 @@ static void* find_NSSCMSGetDecryptKeyCallback_Fct(void* fct)
 
 EXPORT void my_SEC_PKCS12CreateExportContext(x64emu_t* emu, void* f, void* pwfnarg, void* slot, void* wincx)
 {
-    smime3_my_t* my = (smime3_my_t*)my_lib->priv.w.p2;
-
     my->SEC_PKCS12CreateExportContext(find_SECKEYGetPasswordKey_Fct(f), pwfnarg, slot, wincx);
 }
 
 EXPORT void* my_SEC_PKCS12DecoderStart(x64emu_t* emu, void* item, void* slot, void* wincx, void* dOpen, void* dClose, 
     void* dRead, void* dWrite, void* dArg)
 {
-    smime3_my_t* my = (smime3_my_t*)my_lib->priv.w.p2;
-
     return my->SEC_PKCS12DecoderStart(item, slot, wincx, find_digestOpenFn_Fct(dOpen), find_digestCloseFn_Fct(dClose),
                     find_digestIOFn_Fct(dRead), find_digestIOFn_Fct(dWrite), dArg);
 }
 
 EXPORT int my_SEC_PKCS12DecoderValidateBags(x64emu_t* emu, void* ctx, void* f)
 {
-    smime3_my_t* my = (smime3_my_t*)my_lib->priv.w.p2;
-
     return my->SEC_PKCS12DecoderValidateBags(ctx, find_SEC_PKCS12NicknameCollisionCallback_Fct(f));
 }
 
 EXPORT int my_SEC_PKCS12Encode(x64emu_t* emu, void* p12exp, void* f, void* arg)
 {
-    smime3_my_t* my = (smime3_my_t*)my_lib->priv.w.p2;
-
     return my->SEC_PKCS12Encode(p12exp, find_SEC_PKCS12EncoderOutputCallback_Fct(f), arg);
 }
 
@@ -298,19 +269,16 @@ EXPORT void* my_NSS_CMSEncoder_Start(x64emu_t* emu, void* cmsg, void* outputf, v
                 void* dest, void* destpool, void* pwfn, void* pwfnarg,
                 void* decryptcb, void* decryptarg, void* detached, void* items)
 {
-    smime3_my_t* my = (smime3_my_t*)my_lib->priv.w.p2;
-
     return my->NSS_CMSEncoder_Start(cmsg, find_NSSCMSContentCallback_Fct(outputf), outputarg,
                     dest, destpool, find_PK11PasswordFunc_Fct(pwfn), pwfnarg,
                     find_NSSCMSGetDecryptKeyCallback_Fct(decryptcb), decryptarg, detached, items);
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getSmime3My(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeSmime3My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedsmpeg.c b/src/wrapped/wrappedsmpeg.c
index 0df09581..cc552ba5 100755
--- a/src/wrapped/wrappedsmpeg.c
+++ b/src/wrapped/wrappedsmpeg.c
@@ -20,33 +20,11 @@
 const char* smpegName = "libsmpeg-0.4.so.0";
 #define LIBNAME smpeg
 
-typedef void (*vFpp_t)(void*, void*);
-typedef void (*vFpppp_t)(void*, void*, void*, void*);
-typedef void* (*pFppi_t)(void*, void*, int32_t);
-typedef void* (*pFipi_t)(int32_t, void*, int32_t);
-typedef void* (*pFpipi_t)(void*, int32_t, void*, int32_t);
+#define ADDED_FUNCTIONS()           \
 
-typedef struct smpeg_my_s {
-    // functions
-    vFpppp_t    SMPEG_setdisplay;
-    pFppi_t     SMPEG_new_rwops;
-} smpeg_my_t;
+#include "generated/wrappedsmpegtypes.h"
 
-static void* getSMPEGMy(library_t* lib)
-{
-    smpeg_my_t* my = (smpeg_my_t*)calloc(1, sizeof(smpeg_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    GO(SMPEG_setdisplay, vFpppp_t)
-    GO(SMPEG_new_rwops, pFppi_t)
-    #undef GO
-    return my;
-}
-
-static void freeSMPEGMy(void* lib)
-{
-    (void)lib;
-    //smpeg_my_t *my = (smpeg_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -82,15 +60,11 @@ static void* find_dispcallback_Fct(void* fct)
 EXPORT void my_SMPEG_setdisplay(x64emu_t* emu, void* mpeg, void* surf, void* lock, void* cb)
 {
     (void)emu;
-    library_t* lib = GetLibInternal(smpegName);
-    smpeg_my_t* my = (smpeg_my_t*)lib->priv.w.p2;
     my->SMPEG_setdisplay(mpeg, surf, lock, find_dispcallback_Fct(cb));
 }
 
 EXPORT void* my_SMPEG_new_rwops(x64emu_t* emu, void* src, void* info, int32_t sdl_audio)
 {
-    library_t* lib = GetLibInternal(smpegName);
-    smpeg_my_t* my = (smpeg_my_t*)lib->priv.w.p2;
     SDL1_RWops_t* rw = RWNativeStart(emu, (SDL1_RWops_t*)src);
     void* ret = my->SMPEG_new_rwops(rw, info, sdl_audio);
     RWNativeEnd(rw);
@@ -98,10 +72,9 @@ EXPORT void* my_SMPEG_new_rwops(x64emu_t* emu, void* src, void* info, int32_t sd
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getSMPEGMy(lib);
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeSMPEGMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2); \
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedsmpeg2.c b/src/wrapped/wrappedsmpeg2.c
index 05be193e..c95f0bab 100755
--- a/src/wrapped/wrappedsmpeg2.c
+++ b/src/wrapped/wrappedsmpeg2.c
@@ -20,34 +20,11 @@
 const char* smpeg2Name = "libsmpeg2-2.0.so.0";
 #define LIBNAME smpeg2
 
-typedef void (*vFpp_t)(void*, void*);
-typedef void (*vFpppp_t)(void*, void*, void*, void*);
-typedef void* (*pFppi_t)(void*, void*, int32_t);
-typedef void* (*pFipi_t)(int32_t, void*, int32_t);
-typedef void* (*pFpipi_t)(void*, int32_t, void*, int32_t);
-typedef void* (*pFppii_t)(void*, void*, int32_t, int32_t);
+#define ADDED_FUNCTIONS()           \
 
-typedef struct smpeg2_my_s {
-    // functions
-    vFpppp_t    SMPEG_setdisplay;
-    pFppii_t    SMPEG_new_rwops;
-} smpeg2_my_t;
+#include "generated/wrappedsmpeg2types.h"
 
-static void* getSMPEG2My(library_t* lib)
-{
-    smpeg2_my_t* my = (smpeg2_my_t*)calloc(1, sizeof(smpeg2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    GO(SMPEG_setdisplay, vFpppp_t)
-    GO(SMPEG_new_rwops, pFppii_t)
-    #undef GO
-    return my;
-}
-
-static void freeSMPEG2My(void* lib)
-{
-    (void)lib;
-    //smpeg2_my_t *my = (smpeg2_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -84,15 +61,11 @@ static void* find_dispcallback_Fct(void* fct)
 EXPORT void my2_SMPEG_setdisplay(x64emu_t* emu, void* mpeg, void* cb, void* data, void* lock)
 {
     (void)emu;
-    library_t* lib = GetLibInternal(smpeg2Name);
-    smpeg2_my_t* my = (smpeg2_my_t*)lib->priv.w.p2;
     my->SMPEG_setdisplay(mpeg, find_dispcallback_Fct(cb), data, lock);
 }
 
 EXPORT void* my2_SMPEG_new_rwops(x64emu_t* emu, void* src, void* info, int32_t f, int32_t audio)
 {
-    library_t* lib = GetLibInternal(smpeg2Name);
-    smpeg2_my_t* my = (smpeg2_my_t*)lib->priv.w.p2;
     SDL2_RWops_t *rw = RWNativeStart2(emu, (SDL2_RWops_t*)src);
     void* ret = my->SMPEG_new_rwops(rw, info, f, audio);
     if(!f) {
@@ -102,11 +75,10 @@ EXPORT void* my2_SMPEG_new_rwops(x64emu_t* emu, void* src, void* info, int32_t f
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getSMPEG2My(lib); \
-    lib->altmy = strdup("my2_");
+    getMy(lib); \
+    SETALT(my2_);
 
 #define CUSTOM_FINI \
-    freeSMPEG2My(lib->priv.w.p2); \
-    free(lib->priv.w.p2); \
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedudev0.c b/src/wrapped/wrappedudev0.c
index 0ce2b65f..bc5eb289 100755
--- a/src/wrapped/wrappedudev0.c
+++ b/src/wrapped/wrappedudev0.c
@@ -21,35 +21,11 @@ const char* udev0Name = "libudev.so.0";
 // fallback to 1 version... Not sure if really correct (probably not)
 #define ALTNAME "libudev.so.1"
 
-static library_t* my_lib = NULL;
+#define ADDED_FUNCTIONS()           \
 
-typedef void (*vFpp_t)(void*, void*);
+#include "generated/wrappedudev0types.h"
 
-#define SUPER()                 \
-GO(udev_set_log_fn, vFpp_t)     \
-
-typedef struct udev0_my_s {
-    // functions
-    #define GO(A, W)    W A;
-    SUPER()
-    #undef GO
-} udev0_my_t;
-
-static void* getUdev0My(library_t* lib)
-{
-    udev0_my_t* my = (udev0_my_t*)calloc(1, sizeof(udev0_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-static void freeUdev0My(void* lib)
-{
-    (void)lib;
-    //udev0_my_t *my = (udev0_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -95,20 +71,15 @@ static void* find_log_fn_Fct(void* fct)
 
 EXPORT void my0_udev_set_log_fn(x64emu_t* emu, void* udev, void* f)
 {
-    udev0_my_t* my = (udev0_my_t*)my_lib->priv.w.p2;
-
     my->udev_set_log_fn(udev, find_log_fn_Fct(f));
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getUdev0My(lib);   \
-    lib->altmy = strdup("my0_");        \
-    my_lib = lib;
+    SETALT(my0_);   \
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeUdev0My(lib->priv.w.p2);\
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedudev1.c b/src/wrapped/wrappedudev1.c
index 0835bcba..6c30a14c 100755
--- a/src/wrapped/wrappedudev1.c
+++ b/src/wrapped/wrappedudev1.c
@@ -21,35 +21,11 @@ const char* udev1Name = "libudev.so.1";
 // fallback to 0 version... Not sure if really correct (probably not)
 #define ALTNAME "libudev.so.0"
 
-static library_t* my_lib = NULL;
+#define ADDED_FUNCTIONS()           \
 
-typedef void (*vFpp_t)(void*, void*);
+#include "generated/wrappedudev1types.h"
 
-#define SUPER()                 \
-GO(udev_set_log_fn, vFpp_t)     \
-
-typedef struct udev1_my_s {
-    // functions
-    #define GO(A, W)    W A;
-    SUPER()
-    #undef GO
-} udev1_my_t;
-
-static void* getUdev1My(library_t* lib)
-{
-    udev1_my_t* my = (udev1_my_t*)calloc(1, sizeof(udev1_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-
-static void freeUdev1My(void* lib)
-{
-    (void)lib;
-    //udev1_my_t *my = (udev1_my_t *)lib;
-}
-#undef SUPER
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -95,19 +71,14 @@ static void* find_log_fn_Fct(void* fct)
 
 EXPORT void my_udev_set_log_fn(x64emu_t* emu, void* udev, void* f)
 {
-    udev1_my_t* my = (udev1_my_t*)my_lib->priv.w.p2;
-
     my->udev_set_log_fn(udev, find_log_fn_Fct(f));
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getUdev1My(lib); \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeUdev1My(lib->priv.w.p2);\
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedvorbisfile.c b/src/wrapped/wrappedvorbisfile.c
index aa276de3..768c06a6 100755
--- a/src/wrapped/wrappedvorbisfile.c
+++ b/src/wrapped/wrappedvorbisfile.c
@@ -30,38 +30,11 @@ typedef struct {
 
 typedef int32_t (*iFppplC_t)(void*, void*, void*, long, ov_callbacks);
 
-typedef struct vorbisfile_my_s {
-    // functions
-    iFppplC_t       ov_open_callbacks;
-    iFppplC_t       ov_test_callbacks;
-} vorbisfile_my_t;
-
-void* getVorbisfileMy(library_t* lib)
-{
-    vorbisfile_my_t* my = (vorbisfile_my_t*)calloc(1, sizeof(vorbisfile_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    GO(ov_open_callbacks, iFppplC_t)
-    GO(ov_test_callbacks, iFppplC_t)
-    #undef GO
-    return my;
-}
-
-void freeVorbisfileMy(void* lib)
-{
-    (void)lib;
-    //vorbisfile_my_t *my = (vorbisfile_my_t *)lib;
-}
-
-#define CUSTOM_INIT \
-    box64->vorbisfile = lib;\
-    lib->priv.w.p2 = getVorbisfileMy(lib);
-
-#define CUSTOM_FINI \
-    freeVorbisfileMy(lib->priv.w.p2);   \
-    free(lib->priv.w.p2);               \
-    lib->context->vorbisfile = NULL;
+#define SUPER() \
+    GO(ov_open_callbacks, iFppplC_t)    \
+    GO(ov_test_callbacks, iFppplC_t)    \
 
-#include "wrappedlib_init.h"
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)           \
@@ -166,7 +139,6 @@ static void* findtellFct(void* fct)
 
 EXPORT int32_t my_ov_open_callbacks(x64emu_t* emu, void* datasource, void* vf, void* initial, long ibytes, void* read_fnc, void* seek_fnc, void* close_fnc, void* tell_fnc)
 {
-    vorbisfile_my_t* my = (vorbisfile_my_t*)emu->context->vorbisfile->priv.w.p2;
     ov_callbacks cbs = {0};
     cbs.read_func = findreadFct(read_fnc);
     cbs.seek_func = findseekFct(seek_fnc);
@@ -178,7 +150,6 @@ EXPORT int32_t my_ov_open_callbacks(x64emu_t* emu, void* datasource, void* vf, v
 
 EXPORT int32_t my_ov_test_callbacks(x64emu_t* emu, void* datasource, void* vf, void* initial, long ibytes, void* read_fnc, void* seek_fnc, void* close_fnc, void* tell_fnc)
 {
-    vorbisfile_my_t* my = (vorbisfile_my_t*)emu->context->vorbisfile->priv.w.p2;
     ov_callbacks cbs = {0};
     cbs.read_func = findreadFct(read_fnc);
     cbs.seek_func = findseekFct(seek_fnc);
@@ -187,3 +158,20 @@ EXPORT int32_t my_ov_test_callbacks(x64emu_t* emu, void* datasource, void* vf, v
     int32_t ret =  my->ov_test_callbacks(datasource, vf, initial, ibytes, cbs);
     return ret;
 }
+
+#ifdef PANDORA
+// No really ok, because it will depends on the order of initialisation
+#define PRE_INIT \
+    vorbisfileName = (box86->sdl1mixerlib || box86->sdl2mixerlib)?vorbisfileNameAlt:vorbisfileNameReg;
+#endif
+
+#define CUSTOM_INIT \
+    box64->vorbisfile = lib;\
+    getMy(lib);
+
+#define CUSTOM_FINI \
+    freeMy();   \
+    my_context->vorbisfile = NULL;
+
+#include "wrappedlib_init.h"
+
diff --git a/src/wrapped/wrappedvulkan.c b/src/wrapped/wrappedvulkan.c
index 75b14bfb..9e4c53a5 100755
--- a/src/wrapped/wrappedvulkan.c
+++ b/src/wrapped/wrappedvulkan.c
@@ -20,36 +20,20 @@
 
 const char* vulkanName = "libvulkan.so.1";
 #define LIBNAME vulkan
-static library_t *my_lib = NULL;
 
 typedef void(*vFpUp_t)      (void*, uint64_t, void*);
 
 #define ADDED_FUNCTIONS()                           \
     GO(vkDestroySamplerYcbcrConversion, vFpUp_t)    \
 
-
 #include "generated/wrappedvulkantypes.h"
 
-typedef struct vulkan_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
+#define ADDED_STRUCT()                              \
     void* currentInstance;  // track current instance. If using multiple instance, that will be a mess!
-} vulkan_my_t;
 
-void* getVulkanMy(library_t* lib)
-{
-    vulkan_my_t* my = (vulkan_my_t*)calloc(1, sizeof(vulkan_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-void freeVulkanMy(void* p)
-{
-    //vulkan_my_t* my = (vulkan_my_t*)p;
-}
+#define ADDED_SUPER 1
+#include "wrappercallback.h"
+
 void updateInstance(vulkan_my_t* my)
 {
     void* p;
@@ -94,7 +78,6 @@ EXPORT void* my_vkGetDeviceProcAddr(x64emu_t* emu, void* device, void* name)
 {
     khint_t k;
     const char* rname = (const char*)name;
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
 
     if(dlsym_error && box64_log<LOG_DEBUG) printf_log(LOG_NONE, "Calling my_vkGetDeviceProcAddr(%p, \"%s\") => ", device, rname);
     if(!emu->context->vkwrappers)
@@ -125,7 +108,6 @@ EXPORT void* my_vkGetInstanceProcAddr(x64emu_t* emu, void* instance, void* name)
 {
     khint_t k;
     const char* rname = (const char*)name;
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
 
     if(dlsym_error && box64_log<LOG_DEBUG) printf_log(LOG_NONE, "Calling my_vkGetInstanceProcAddr(%p, \"%s\") => ", instance, rname);
     if(!emu->context->vkwrappers)
@@ -318,15 +300,12 @@ static void* find_DebugReportCallbackEXT_Fct(void* fct)
         return -1;
 
 #define CUSTOM_INIT \
-    my_lib = lib; \
-    lib->priv.w.p2 = getVulkanMy(lib);  \
+    getMy(lib);     \
     lib->priv.w.priv = dlsym(lib->priv.w.lib, "vkGetInstanceProcAddr"); \
     box64->vkprocaddress = lib->priv.w.priv;
 
 #define CUSTOM_FINI \
-    my_lib = NULL;  \
-    freeVulkanMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);
+    freeMy();
 
 #include "wrappedlib_init.h"
 
@@ -384,21 +363,18 @@ my_VkAllocationCallbacks_t* find_VkAllocationCallbacks(my_VkAllocationCallbacks_
 #define CREATE(A)   \
 EXPORT int my_##A(x64emu_t* emu, void* device, void* pAllocateInfo, my_VkAllocationCallbacks_t* pAllocator, void* p)    \
 {                                                                                                                       \
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;                                                                  \
     my_VkAllocationCallbacks_t my_alloc;                                                                                \
     return my->A(device, pAllocateInfo, find_VkAllocationCallbacks(&my_alloc, pAllocator), p);                          \
 }
 #define DESTROY(A)   \
 EXPORT void my_##A(x64emu_t* emu, void* device, void* p, my_VkAllocationCallbacks_t* pAllocator)                        \
 {                                                                                                                       \
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;                                                                  \
     my_VkAllocationCallbacks_t my_alloc;                                                                                \
     my->A(device, p, find_VkAllocationCallbacks(&my_alloc, pAllocator));                                                \
 }
 #define DESTROY64(A)   \
 EXPORT void my_##A(x64emu_t* emu, void* device, uint64_t p, my_VkAllocationCallbacks_t* pAllocator)                     \
 {                                                                                                                       \
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;                                                                  \
     my_VkAllocationCallbacks_t my_alloc;                                                                                \
     my->A(device, p, find_VkAllocationCallbacks(&my_alloc, pAllocator));                                                \
 }
@@ -410,7 +386,6 @@ CREATE(vkCreateCommandPool)
 
 EXPORT int my_vkCreateComputePipelines(x64emu_t* emu, void* device, uint64_t pipelineCache, uint32_t count, void* pCreateInfos, my_VkAllocationCallbacks_t* pAllocator, void* pPipelines)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     int ret = my->vkCreateComputePipelines(device, pipelineCache, count, pCreateInfos, find_VkAllocationCallbacks(&my_alloc, pAllocator), pPipelines);
     return ret;
@@ -424,7 +399,6 @@ CREATE(vkCreateDevice)
 
 EXPORT int my_vkCreateDisplayModeKHR(x64emu_t* emu, void* physical, uint64_t display, void* pCreateInfo, my_VkAllocationCallbacks_t* pAllocator, void* pMode)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     return my->vkCreateDisplayModeKHR(physical, display, pCreateInfo, find_VkAllocationCallbacks(&my_alloc, pAllocator), pMode);
 }
@@ -436,7 +410,6 @@ CREATE(vkCreateFramebuffer)
 
 EXPORT int my_vkCreateGraphicsPipelines(x64emu_t* emu, void* device, uint64_t pipelineCache, uint32_t count, void* pCreateInfos, my_VkAllocationCallbacks_t* pAllocator, void* pPipelines)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     int ret = my->vkCreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, find_VkAllocationCallbacks(&my_alloc, pAllocator), pPipelines);
     return ret;
@@ -447,7 +420,6 @@ CREATE(vkCreateImageView)
 
 EXPORT int my_vkCreateInstance(x64emu_t* emu, void* pCreateInfos, my_VkAllocationCallbacks_t* pAllocator, void* pInstance)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     return my->vkCreateInstance(pCreateInfos, find_VkAllocationCallbacks(&my_alloc, pAllocator), pInstance);
 }
@@ -463,7 +435,6 @@ CREATE(vkCreateShaderModule)
 
 EXPORT int my_vkCreateSharedSwapchainsKHR(x64emu_t* emu, void* device, uint32_t count, void** pCreateInfos, my_VkAllocationCallbacks_t* pAllocator, void* pSwapchains)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     int ret = my->vkCreateSharedSwapchainsKHR(device, count, pCreateInfos, find_VkAllocationCallbacks(&my_alloc, pAllocator), pSwapchains);
     return ret;
@@ -478,13 +449,11 @@ CREATE(vkCreateRenderPass2KHR)
 
 EXPORT int my_vkRegisterDeviceEventEXT(x64emu_t* emu, void* device, void* info, my_VkAllocationCallbacks_t* pAllocator, void* pFence)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     return my->vkRegisterDeviceEventEXT(device, info, find_VkAllocationCallbacks(&my_alloc, pAllocator), pFence);
 }
 EXPORT int my_vkRegisterDisplayEventEXT(x64emu_t* emu, void* device, uint64_t disp, void* info, my_VkAllocationCallbacks_t* pAllocator, void* pFence)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     return my->vkRegisterDisplayEventEXT(device, disp, info, find_VkAllocationCallbacks(&my_alloc, pAllocator), pFence);
 }
@@ -501,7 +470,6 @@ DESTROY64(vkDestroyDescriptorUpdateTemplateKHR)
 
 EXPORT void my_vkDestroyDevice(x64emu_t* emu, void* pDevice, my_VkAllocationCallbacks_t* pAllocator)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     my->vkDestroyDevice(pDevice, find_VkAllocationCallbacks(&my_alloc, pAllocator));
 }
@@ -514,7 +482,6 @@ DESTROY64(vkDestroyImageView)
 
 EXPORT void my_vkDestroyInstance(x64emu_t* emu, void* instance, my_VkAllocationCallbacks_t* pAllocator)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     my->vkDestroyInstance(instance, find_VkAllocationCallbacks(&my_alloc, pAllocator));
 }
@@ -543,46 +510,39 @@ DESTROY64(vkDestroyValidationCacheEXT)
 
 EXPORT void my_vkGetPhysicalDeviceProperties(x64emu_t* emu, void* device, void* pProps)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my->vkGetPhysicalDeviceProperties(device, pProps);
 }
 
 EXPORT void my_vkGetPhysicalDeviceSparseImageFormatProperties(x64emu_t* emu, void* device, int format, int type, int samples, int usage, int tiling, uint32_t* count, void** pProps)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my->vkGetPhysicalDeviceSparseImageFormatProperties(device, format, type, samples, usage, tiling, count, pProps);
 }
 
 EXPORT void my_vkUpdateDescriptorSets(x64emu_t* emu, void* device, uint32_t writeCount, void* writeSet, uint32_t copyCount, void* copySet)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my->vkUpdateDescriptorSets(device, writeCount, writeSet, copyCount, copySet);
 }
 
 EXPORT int my_vkGetDisplayPlaneCapabilitiesKHR(x64emu_t* emu, void* device, uint64_t mode, uint32_t index, void* pCap)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     int ret = my->vkGetDisplayPlaneCapabilitiesKHR(device, mode, index, pCap);
     return ret;
 }
 
 EXPORT int my_vkGetPhysicalDeviceDisplayPropertiesKHR(x64emu_t* emu, void* device, uint32_t* count, void* pProp)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     int ret = my->vkGetPhysicalDeviceDisplayPropertiesKHR(device, count, pProp);
     return ret;
 }
 
 EXPORT void my_vkGetPhysicalDeviceMemoryProperties(x64emu_t* emu, void* device, void* pProps)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my->vkGetPhysicalDeviceMemoryProperties(device, pProps);
 }
 
 EXPORT void my_vkCmdPipelineBarrier(x64emu_t* emu, void* device, int src, int dst, int dep, 
     uint32_t barrierCount, void* pBarriers, uint32_t bufferCount, void* pBuffers, uint32_t imageCount, void* pImages)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my->vkCmdPipelineBarrier(device, src, dst, dep, barrierCount, pBarriers, bufferCount, pBuffers, imageCount, pImages);
 }
 
@@ -598,7 +558,6 @@ EXPORT int my_vkCreateDebugReportCallbackEXT(x64emu_t* emu, void* instance,
                                              my_VkDebugReportCallbackCreateInfoEXT_t* create, 
                                              my_VkAllocationCallbacks_t* alloc, void* callback)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkDebugReportCallbackCreateInfoEXT_t dbg = *create;
     my_VkAllocationCallbacks_t my_alloc; 
     dbg.pfnCallback = find_DebugReportCallbackEXT_Fct(dbg.pfnCallback);
@@ -607,7 +566,6 @@ EXPORT int my_vkCreateDebugReportCallbackEXT(x64emu_t* emu, void* instance,
 
 EXPORT int my_vkDestroyDebugReportCallbackEXT(x64emu_t* emu, void* instance, void* callback, void* alloc)
 {
-    vulkan_my_t* my = (vulkan_my_t*)my_lib->priv.w.p2;
     my_VkAllocationCallbacks_t my_alloc;
     return my->vkDestroyDebugReportCallbackEXT(instance, callback, find_VkAllocationCallbacks(&my_alloc, alloc));
 }
diff --git a/src/wrapped/wrappedxinerama.c b/src/wrapped/wrappedxinerama.c
index 683c40e7..d105f361 100755
--- a/src/wrapped/wrappedxinerama.c
+++ b/src/wrapped/wrappedxinerama.c
@@ -15,10 +15,7 @@ const char* xineramaName = "libXinerama.so.1";
 #define LIBNAME xinerama
 
 #define CUSTOM_INIT \
-    lib->priv.w.needed = 2; \
-    lib->priv.w.neededlibs = (char**)calloc(lib->priv.w.needed, sizeof(char*)); \
-    lib->priv.w.neededlibs[0] = strdup("libX11.so.6"); \
-    lib->priv.w.neededlibs[1] = strdup("libXext.so.6");
+    setNeededLibs(&lib->priv.w, 2, "libX11.so.6", "libXext.so.6");
 
 #include "wrappedlib_init.h"
 
diff --git a/src/wrapped/wrappedxml2.c b/src/wrapped/wrappedxml2.c
index 59381544..e8c68206 100755
--- a/src/wrapped/wrappedxml2.c
+++ b/src/wrapped/wrappedxml2.c
@@ -24,56 +24,7 @@ const char* xml2Name =
 #endif
     ;
 #define LIBNAME xml2
-static library_t *my_lib = NULL;
 
-typedef int     (*iFv_t)        ();
-typedef void*   (*pFv_t)        ();
-typedef void    (*vFp_t)        (void*);
-typedef int     (*iFp_t)        (void*);
-typedef void*   (*pFpp_t)       (void*, void*);
-typedef void    (*vFpp_t)       (void*, void*);
-typedef int     (*iFppp_t)      (void*, void*, void*);
-typedef void    (*vFppp_t)      (void*, void*, void*);
-typedef void*   (*pFppp_t)      (void*, void*, void*);
-typedef void*   (*pFpppi_t)     (void*, void*, void*, int);
-typedef int     (*iFpppp_t)     (void*, void*, void*, void*);
-typedef void    (*vFpppp_t)     (void*, void*, void*, void*);
-typedef void*   (*pFpppp_t)     (void*, void*, void*, void*);
-typedef void*   (*pFppppi_t)    (void*, void*, void*, void*, int);
-typedef int     (*iFppppp_t)    (void*, void*, void*, void*, void*);
-typedef void    (*vFppppp_t)    (void*, void*, void*, void*, void*);
-typedef int     (*iFpppppp_t)   (void*, void*, void*, void*, void*, void*);
-typedef void    (*vFpppppp_t)   (void*, void*, void*, void*, void*, void*);
-typedef void*   (*pFpppppi_t)   (void*, void*, void*, void*, void*, int);
-
-#define SUPER()                                     \
-    GO(xmlHashCopy, pFpp_t)                         \
-    GO(xmlHashFree, vFpp_t)                         \
-    GO(xmlHashRemoveEntry, iFppp_t)                 \
-    GO(xmlHashRemoveEntry2, iFpppp_t)               \
-    GO(xmlHashRemoveEntry3, iFppppp_t)              \
-    GO(xmlHashScan, vFppp_t)                        \
-    GO(xmlHashScan3, vFpppppp_t)                    \
-    GO(xmlHashScanFull, vFppp_t)                    \
-    GO(xmlHashScanFull3, vFpppppp_t)                \
-    GO(xmlHashUpdateEntry, iFpppp_t)                \
-    GO(xmlHashUpdateEntry2, iFppppp_t)              \
-    GO(xmlHashUpdateEntry3, iFpppppp_t)             \
-    GO(xmlGetExternalEntityLoader, pFv_t)           \
-    GO(xmlNewCharEncodingHandler, pFppp_t)          \
-    GO(xmlOutputBufferCreateIO, pFpppp_t)           \
-    GO(xmlRegisterInputCallbacks, iFpppp_t)         \
-    GO(xmlSaveToIO, pFppppi_t)                      \
-    GO(xmlSchemaSetParserErrors, vFpppp_t)          \
-    GO(xmlSchemaSetParserStructuredErrors, vFppp_t) \
-    GO(xmlSchemaSetValidErrors, vFpppp_t)           \
-    GO(xmlSchemaSetValidStructuredErrors, vFppp_t)  \
-    GO(xmlSetExternalEntityLoader, vFp_t)           \
-    GO(xmlXPathRegisterFunc, iFppp_t)               \
-    GO(xmlParserInputBufferCreateIO, pFpppi_t)      \
-    GO(xmlInitMemory, iFv_t)                        \
-    GO(xmlParseDocument, iFp_t)                     \
-    GO(xmlCreateIOParserCtxt, pFpppppi_t)           \
 
 EXPORT uintptr_t my_xmlFree = 0;
 EXPORT uintptr_t my_xmlMalloc = 0;
@@ -110,39 +61,26 @@ void* my_wrap_xmlMemStrdup(void* p)
         return strdup(p);
 }
 
-typedef struct xml2_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} xml2_my_t;
+#define ADDED_FUNCTIONS() \
 
-void* getXml2My(library_t* lib)
-{
-    xml2_my_t* my = (xml2_my_t*)calloc(1, sizeof(xml2_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    void** p;
-    // wrap memory pointer
-    #define GO(A, W)                                                                    \
-        p=dlsym(lib->priv.w.lib, #A);                                                   \
-        printf_log(LOG_DEBUG, "Wrapping %s=>%p(%p) from lixml2\n", #A, p, p?*p:NULL);   \
-        my_##A = (p && *p)?AddBridge(lib->priv.w.bridge, W, *p, 0, #A):0;               \
-        if(p) *p = my_wrap_##A
-    GO(xmlFree, vFp);
-    GO(xmlMalloc, pFL);
-    GO(xmlRealloc, pFpL);
-    GO(xmlMemStrdup, pFp);
-    #undef GO
-    return my;
-}
-#undef SUPER
+#include "generated/wrappedxml2types.h"
 
-void freeXml2My(void* lib)
-{
-    //xml2_my_t *my = (xml2_my_t *)lib;
-}
+#define ADDED_INIT() \
+    void** p;                                                                                               \
+    p=dlsym(lib->priv.w.lib, "xmlFree");                                                                    \
+        my_xmlFree = (p && *p)?AddBridge(lib->priv.w.bridge, vFp, *p, 0, "my_wrap_xmlFree"):0;              \
+        if(p) *p = my_wrap_xmlFree;                                                                         \
+    p=dlsym(lib->priv.w.lib, "xmlMalloc");                                                                  \
+        my_xmlMalloc = (p && *p)?AddBridge(lib->priv.w.bridge, pFL, *p, 0, "my_wrap_xmlMalloc"):0;          \
+        if(p) *p = my_wrap_xmlMalloc;                                                                       \
+    p=dlsym(lib->priv.w.lib, "xmlRealloc");                                                                 \
+        my_xmlRealloc = (p && *p)?AddBridge(lib->priv.w.bridge, pFpL, *p, 0, "my_wrap_xmlRealloc"):0;       \
+        if(p) *p = my_wrap_xmlRealloc;                                                                      \
+    p=dlsym(lib->priv.w.lib, "xmlMemStrdup");                                                               \
+        my_xmlMemStrdup = (p && *p)?AddBridge(lib->priv.w.bridge, pFp, *p, 0, "my_wrap_xmlMemStrdup"):0;    \
+        if(p) *p = my_wrap_xmlMemStrdup;
+
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -1185,162 +1123,114 @@ static void* reverse_xmlExternalEntityLoaderFct(void* fct)
 
 EXPORT void* my_xmlHashCopy(x64emu_t* emu, void* table, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlHashCopy(table, find_xmlHashCopier_Fct(f));
 }
 
 EXPORT void my_xmlHashFree(x64emu_t* emu, void* table, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlHashFree(table, find_xmlHashDeallocator_Fct(f));
 }
 
 EXPORT int my_xmlHashRemoveEntry(x64emu_t* emu, void* table, void* name, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlHashRemoveEntry(table, name, find_xmlHashDeallocator_Fct(f));
 }
 EXPORT int my_xmlHashRemoveEntry2(x64emu_t* emu, void* table, void* name, void* name2, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlHashRemoveEntry2(table, name, name2, find_xmlHashDeallocator_Fct(f));
 }
 EXPORT int my_xmlHashRemoveEntry3(x64emu_t* emu, void* table, void* name, void* name2, void* name3, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlHashRemoveEntry3(table, name, name2, name3, find_xmlHashDeallocator_Fct(f));
 }
 
 EXPORT void my_xmlHashScan(x64emu_t* emu, void* table, void* f, void* data)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlHashScan(table, find_xmlHashScanner_Fct(f), data);
 }
 EXPORT void my_xmlHashScan3(x64emu_t* emu, void* table, void* name, void* name2, void* name3, void* f, void* data)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlHashScan3(table, name, name2, name3, find_xmlHashScanner_Fct(f), data);
 }
 EXPORT void my_xmlHashScanFull(x64emu_t* emu, void* table, void* f, void* data)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlHashScanFull(table, find_xmlHashScannerFull_Fct(f), data);
 }
 EXPORT void my_xmlHashScanFull3(x64emu_t* emu, void* table, void* name, void* name2, void* name3, void* f, void* data)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlHashScanFull3(table, name, name2, name3, find_xmlHashScannerFull_Fct(f), data);
 }
 
 EXPORT int my_xmlHashUpdateEntry(x64emu_t* emu, void* table, void* name, void* data, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlHashUpdateEntry(table, name, data, find_xmlHashDeallocator_Fct(f));
 }
 EXPORT int my_xmlHashUpdateEntry2(x64emu_t* emu, void* table, void* name, void* name2, void* data, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlHashUpdateEntry2(table, name, name2, data, find_xmlHashDeallocator_Fct(f));
 }
 EXPORT int my_xmlHashUpdateEntry3(x64emu_t* emu, void* table, void* name, void* name2, void* name3, void* data, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlHashUpdateEntry3(table, name, name2, name3, data, find_xmlHashDeallocator_Fct(f));
 }
 
 EXPORT void* my_xmlGetExternalEntityLoader(x64emu_t* emu)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return reverse_xmlExternalEntityLoaderFct(my->xmlGetExternalEntityLoader());
 }
 
 EXPORT void* my_xmlNewCharEncodingHandler(x64emu_t* emu, void* name, void* fin, void* fout)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlNewCharEncodingHandler(name, find_xmlCharEncodingInputFunc_Fct(fin), find_xmlCharEncodingOutputFunc_Fct(fout));
 }
 
 EXPORT void* my_xmlOutputBufferCreateIO(x64emu_t* emu, void* fwrite, void* fclose, void* ioctx, void* encoder)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlOutputBufferCreateIO(find_xmlOutputWriteCallback_Fct(fwrite), find_xmlOutputCloseCallback_Fct(fclose), ioctx, encoder);
 }
 
 EXPORT int my_xmlRegisterInputCallbacks(x64emu_t* emu, void* fmatch, void* fop, void* frd, void* fcl)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlRegisterInputCallbacks(find_xmlInputMatchCallback_Fct(fmatch), find_xmlInputOpenCallback_Fct(fop), find_xmlInputReadCallback_Fct(frd), find_xmlInputCloseCallback_Fct(fcl));
 }
 
 EXPORT void* my_xmlSaveToIO(x64emu_t* emu, void* fwrt, void* fcl, void* ioctx, void* encoding, int options)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlSaveToIO(find_xmlOutputWriteCallback_Fct(fwrt), find_xmlOutputCloseCallback_Fct(fcl), ioctx, encoding, options);
 }
 
 EXPORT void my_xmlSchemaSetParserErrors(x64emu_t* emu, void* ctxt, void* ferr, void* fwarn, void* ctx)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlSchemaSetParserErrors(ctxt, find_xmlSchemaValidityErrorFunc_Fct(ferr), find_xmlSchemaValidityWarningFunc_Fct(fwarn), ctx);
 }
 
 EXPORT void my_xmlSchemaSetParserStructuredErrors(x64emu_t* emu, void* ctxt, void* ferr, void* ctx)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlSchemaSetParserStructuredErrors(ctxt, find_xmlStructuredErrorFunc_Fct(ferr), ctx);
 }
 
 EXPORT void my_xmlSchemaSetValidErrors(x64emu_t* emu, void* ctxt, void* ferr, void* fwarn, void* ctx)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlSchemaSetValidErrors(ctxt, find_xmlSchemaValidityErrorFunc_Fct(ferr), find_xmlSchemaValidityWarningFunc_Fct(fwarn), ctx);
 }
 
 EXPORT void my_xmlSchemaSetValidStructuredErrors(x64emu_t* emu, void* ctxt, void* ferr, void* ctx)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlSchemaSetValidStructuredErrors(ctxt, find_xmlStructuredErrorFunc_Fct(ferr), ctx);
 }
 
 EXPORT void my_xmlSetExternalEntityLoader(x64emu_t* emu, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     my->xmlSetExternalEntityLoader(find_xmlExternalEntityLoaderFct(f));
 }
 
 EXPORT int my_xmlXPathRegisterFunc(x64emu_t* emu, void* ctxt, void* name, void* f)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlXPathRegisterFunc(ctxt, name, find_xmlXPathFunction_Fct(f));
 }
 
 EXPORT void* my_xmlParserInputBufferCreateIO(x64emu_t* emu, void* ioread, void* ioclose, void* ioctx, int enc)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
-
     return my->xmlParserInputBufferCreateIO(find_xmlInputReadCallback_Fct(ioread), find_xmlInputCloseCallback_Fct(ioclose), ioctx, enc);
 }
 
@@ -1407,7 +1297,6 @@ static void restoreSaxHandler(my_xmlSAXHandler_t* sav, my_xmlSAXHandler_t* v)
 
 EXPORT int my_xmlParseDocument(x64emu_t* emu, my_xmlSAXHandler_t** p)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
     // handling of wine that change the default sax handler of...
     my_xmlSAXHandler_t* old_saxhandler = p?(*p):NULL;
     my_xmlSAXHandler_t sax_handler = {0};
@@ -1419,7 +1308,6 @@ EXPORT int my_xmlParseDocument(x64emu_t* emu, my_xmlSAXHandler_t** p)
 
 EXPORT void* my_xmlCreateIOParserCtxt(x64emu_t* emu, my_xmlSAXHandler_t** p, void* user_data, void* ioread, void* ioclose, void* ioctx, int enc)
 {
-    xml2_my_t* my = (xml2_my_t*)my_lib->priv.w.p2;
     // handling of wine that change the default sax handler of...
     my_xmlSAXHandler_t* old_saxhandler = p?(*p):NULL;
     my_xmlSAXHandler_t sax_handler = {0};
@@ -1430,12 +1318,9 @@ EXPORT void* my_xmlCreateIOParserCtxt(x64emu_t* emu, my_xmlSAXHandler_t** p, voi
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getXml2My(lib);    \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeXml2My(lib->priv.w.p2); \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedxslt.c b/src/wrapped/wrappedxslt.c
index a3aff7df..41e68636 100755
--- a/src/wrapped/wrappedxslt.c
+++ b/src/wrapped/wrappedxslt.c
@@ -24,36 +24,12 @@ const char *xsltName =
 #endif
     ;
 #define LIBNAME xslt
-static library_t *my_lib = NULL;
 
-typedef void    (*vFp_t)        (void*);
-typedef int     (*iFppp_t)      (void*, void*, void*);
+#define ADDED_FUNCTIONS() \
 
-#define SUPER()                                 \
-    GO(xsltRegisterExtModuleFunction, iFppp_t)  \
-    GO(xsltSetLoaderFunc, vFp_t)                \
+#include "generated/wrappedxslttypes.h"
 
-typedef struct xslt_my_s {
-    // functions
-    #define GO(A, B)    B   A;
-    SUPER()
-    #undef GO
-} xslt_my_t;
-
-void* getXsltMy(library_t* lib)
-{
-    xslt_my_t* my = (xslt_my_t*)calloc(1, sizeof(xslt_my_t));
-    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
-    SUPER()
-    #undef GO
-    return my;
-}
-#undef SUPER
-
-void freeXsltMy(void* lib)
-{
-    //xslt_my_t *my = (xslt_my_t *)lib;
-}
+#include "wrappercallback.h"
 
 #define SUPER() \
 GO(0)   \
@@ -111,25 +87,18 @@ static void* find_xsltDocLoaderFunc_Fct(void* fct)
 
 EXPORT int my_xsltRegisterExtModuleFunction(x64emu_t* emu, void* name, void* URI, void* f)
 {
-    xslt_my_t* my = (xslt_my_t*)my_lib->priv.w.p2;
-
     return my->xsltRegisterExtModuleFunction(name, URI, find_xmlXPathFunction_Fct(f));
 }
 
 EXPORT void my_xsltSetLoaderFunc(x64emu_t* emu, void* f)
 {
-    xslt_my_t* my = (xslt_my_t*)my_lib->priv.w.p2;
-
     my->xsltSetLoaderFunc(find_xsltDocLoaderFunc_Fct(f));
 }
 
 #define CUSTOM_INIT \
-    lib->priv.w.p2 = getXsltMy(lib);    \
-    my_lib = lib;
+    getMy(lib);
 
 #define CUSTOM_FINI \
-    freeXsltMy(lib->priv.w.p2); \
-    free(lib->priv.w.p2);       \
-    my_lib = NULL;
+    freeMy();
 
 #include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappercallback.h b/src/wrapped/wrappercallback.h
new file mode 100644
index 00000000..2886965e
--- /dev/null
+++ b/src/wrapped/wrappercallback.h
@@ -0,0 +1,41 @@
+
+#define TYPENAME3(N,M) N##M
+#define TYPENAME2(N,M) TYPENAME3(N,M)
+#define TYPENAME(N) TYPENAME2(LIBNAME, _my_t)
+
+typedef struct TYPENAME2(LIBNAME, _my_s) {
+    // functions
+    #define GO(A, B)    B   A;
+    SUPER()
+    #undef GO
+    #ifdef ADDED_STRUCT
+    ADDED_STRUCT()
+    #endif
+} TYPENAME(LIBNAME);
+
+static library_t* my_lib = NULL;
+static TYPENAME(LIBNAME) TYPENAME2(my_, LIBNAME) = {0};
+static TYPENAME(LIBNAME) * const my = &TYPENAME2(my_, LIBNAME);
+
+static void getMy(library_t* lib)
+{
+    #define GO(A, W) my->A = (W)dlsym(lib->priv.w.lib, #A);
+    SUPER()
+    #undef GO
+    my_lib = lib;
+    #ifdef ADDED_INIT
+    ADDED_INIT()
+    #endif
+}
+
+static void freeMy()
+{
+    my_lib = NULL;
+    #ifdef ADDED_FINI
+    ADDED_FINI()
+    #endif
+}
+
+#ifndef ADDED_SUPER
+#undef SUPER
+#endif