diff --git a/builtin/__builtin__.c b/builtin/__builtin__.c
index 969e22fd3..bdcb37ee5 100644
--- a/builtin/__builtin__.c
+++ b/builtin/__builtin__.c
@@ -1,3 +1,4 @@
+#include "gc/gc_typed.h"
 /*
 Building project in /Users/sydow/acton/builtin/ty
   Compiling __builtin__.act for release in stub mode
@@ -15,7 +16,7 @@ void B_valueD___serialize__ (B_value self, $Serial$state state) {
 B_value B_valueD___deserialize__ (B_value self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_value));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_value), B_valueG_methods.$GCdescr);
             self->$class = &B_valueG_methods;
             return self;
         }
@@ -24,18 +25,19 @@ B_value B_valueD___deserialize__ (B_value self, $Serial$state state) {
     return self;
 }
 B_value B_valueG_new() {
-    B_value $tmp = malloc(sizeof(struct B_value));
+    B_value $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_value), B_valueG_methods.$GCdescr);
     $tmp->$class = &B_valueG_methods;
     B_valueG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_valueG_class B_valueG_methods;
+GC_word B_valueD_gcbm[GC_BITMAP_SIZE(struct B_value)];
 void B_objectD___serialize__ (B_object self, $Serial$state state) {
 }
 B_object B_objectD___deserialize__ (B_object self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_object));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_object), B_objectG_methods.$GCdescr);
             self->$class = &B_objectG_methods;
             return self;
         }
@@ -44,18 +46,19 @@ B_object B_objectD___deserialize__ (B_object self, $Serial$state state) {
     return self;
 }
 B_object B_objectG_new() {
-    B_object $tmp = malloc(sizeof(struct B_object));
+    B_object $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_object), B_objectG_methods.$GCdescr);
     $tmp->$class = &B_objectG_methods;
     B_objectG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_objectG_class B_objectG_methods;
+GC_word B_objectD_gcbm[GC_BITMAP_SIZE(struct B_object)];
 void B_atomD___serialize__ (B_atom self, $Serial$state state) {
 }
 B_atom B_atomD___deserialize__ (B_atom self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_atom));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_atom), B_atomG_methods.$GCdescr);
             self->$class = &B_atomG_methods;
             return self;
         }
@@ -65,13 +68,14 @@ B_atom B_atomD___deserialize__ (B_atom self, $Serial$state state) {
 }
 /*
 B_atom B_atomG_new() {
-    B_atom $tmp = malloc(sizeof(struct B_atom));
+    B_atom $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_atom), B_atomG_methods.$GCdescr);
     $tmp->$class = &B_atomG_methods;
     B_atomG_methods.__init__($tmp);
     return $tmp;
 }
 */
 struct B_atomG_class B_atomG_methods;
+GC_word B_atomD_gcbm[GC_BITMAP_SIZE(struct B_atom)];
 /*
 B_NoneType B_intD___init__ (B_int self, B_atom val);
 void B_intD___serialize__ (B_int self, $Serial$state state) {
@@ -79,7 +83,7 @@ void B_intD___serialize__ (B_int self, $Serial$state state) {
 B_int B_intD___deserialize__ (B_int self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_int));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_int), B_intG_methods.$GCdescr);
             self->$class = &B_intG_methods;
             return self;
         }
@@ -88,13 +92,14 @@ B_int B_intD___deserialize__ (B_int self, $Serial$state state) {
     return self;
 }
 B_int B_intG_new(B_atom G_1) {
-    B_int $tmp = malloc(sizeof(struct B_int));
+    B_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_int), B_intG_methods.$GCdescr);
     $tmp->$class = &B_intG_methods;
     B_intG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 */
 struct B_intG_class B_intG_methods;
+GC_word B_intD_gcbm[GC_BITMAP_SIZE(struct B_int)];
 /*
 B_NoneType B_i64D___init__ (B_i64 self, B_atom val);
 void B_i64D___serialize__ (B_i64 self, $Serial$state state){
@@ -102,7 +107,7 @@ void B_i64D___serialize__ (B_i64 self, $Serial$state state){
 B_i64 B_i64D___deserialize__ (B_i64 self, $Serial$state state); {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_i64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_i64), B_i64G_methods.$GCdescr);
             self->$class = &B_i64G_methods;
             return self;
         }
@@ -111,18 +116,24 @@ B_i64 B_i64D___deserialize__ (B_i64 self, $Serial$state state); {
     return self;
 }
 B_i64 B_i64G_new(B_atom G_1) {
-    B_i64 $tmp = malloc(sizeof(struct B_i64));
+    B_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_i64), B_i64G_methods.$GCdescr);
     $tmp->$class = &B_i64G_methods;
     B_i64G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 */
 struct B_i64G_class B_i64G_methods;
+GC_word B_i64D_gcbm[GC_BITMAP_SIZE(struct B_i64)];
 struct B_i32G_class B_i32G_methods;
+GC_word B_i32D_gcbm[GC_BITMAP_SIZE(struct B_i32)];
 struct B_i16G_class B_i16G_methods;
+GC_word B_i16D_gcbm[GC_BITMAP_SIZE(struct B_i16)];
 struct B_u64G_class B_u64G_methods;
+GC_word B_u64D_gcbm[GC_BITMAP_SIZE(struct B_u64)];
 struct B_u32G_class B_u32G_methods;
+GC_word B_u32D_gcbm[GC_BITMAP_SIZE(struct B_u32)];
 struct B_u16G_class B_u16G_methods;
+GC_word B_u16D_gcbm[GC_BITMAP_SIZE(struct B_u16)];
 /*
 B_NoneType B_floatD___init__ (B_float self, B_atom val);
 void B_floatD___serialize__ (B_float self, $Serial$state state) {
@@ -130,7 +141,7 @@ void B_floatD___serialize__ (B_float self, $Serial$state state) {
 B_float B_floatD___deserialize__ (B_float self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_float));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_float), B_floatG_methods.$GCdescr);
             self->$class = &B_floatG_methods;
             return self;
         }
@@ -139,13 +150,14 @@ B_float B_floatD___deserialize__ (B_float self, $Serial$state state) {
     return self;
 }
 B_float B_floatG_new(B_atom G_1) {
-    B_float $tmp = malloc(sizeof(struct B_float));
+    B_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_float), B_floatG_methods.$GCdescr);
     $tmp->$class = &B_floatG_methods;
     B_floatG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 */
 struct B_floatG_class B_floatG_methods;
+GC_word B_floatD_gcbm[GC_BITMAP_SIZE(struct B_float)];
 /*
 B_NoneType B_boolD___init__ (B_bool self, B_value val);
 void B_boolD___serialize__ (B_bool self, $Serial$state state) {
@@ -153,7 +165,7 @@ void B_boolD___serialize__ (B_bool self, $Serial$state state) {
 B_bool B_boolD___deserialize__ (B_bool self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_bool));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bool), B_boolG_methods.$GCdescr);
             self->$class = &B_boolG_methods;
             return self;
         }
@@ -162,13 +174,14 @@ B_bool B_boolD___deserialize__ (B_bool self, $Serial$state state) {
     return self;
 }
 B_bool B_boolG_new(B_value G_1) {
-    B_bool $tmp = malloc(sizeof(struct B_bool));
+    B_bool $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bool), B_boolG_methods.$GCdescr);
     $tmp->$class = &B_boolG_methods;
     B_boolG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 */
 struct B_boolG_class B_boolG_methods;
+GC_word B_boolD_gcbm[GC_BITMAP_SIZE(struct B_bool)];
 /*
 B_NoneType B_sliceD___init__ (B_slice self, B_int start, B_int stop, B_int step);
 void B_sliceD___serialize__ (B_slice self, $Serial$state state) {
@@ -176,7 +189,7 @@ void B_sliceD___serialize__ (B_slice self, $Serial$state state) {
 B_slice B_sliceD___deserialize__ (B_slice self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_slice));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_slice), B_sliceG_methods.$GCdescr);
             self->$class = &B_sliceG_methods;
             return self;
         }
@@ -185,13 +198,14 @@ B_slice B_sliceD___deserialize__ (B_slice self, $Serial$state state) {
     return self;
 }
 B_slice B_sliceG_new(B_int G_1, B_int G_2, B_int G_3) {
-    B_slice $tmp = malloc(sizeof(struct B_slice));
+    B_slice $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_slice), B_sliceG_methods.$GCdescr);
     $tmp->$class = &B_sliceG_methods;
     B_sliceG_methods.__init__($tmp, G_1, G_2, G_3);
     return $tmp;
 }
 */
 struct B_sliceG_class B_sliceG_methods;
+GC_word B_sliceD_gcbm[GC_BITMAP_SIZE(struct B_slice)];
 /*
 B_NoneType B_listD___init__ (B_list self, B_Iterable W_IterableE_62, $WORD val);
 B_list B_listD_copy (B_list self);
@@ -200,7 +214,7 @@ void B_listD___serialize__ (B_list self, $Serial$state state) {
 B_list B_listD___deserialize__ (B_list self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_list));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_list), B_listG_methods.$GCdescr);
             self->$class = &B_listG_methods;
             return self;
         }
@@ -209,13 +223,14 @@ B_list B_listD___deserialize__ (B_list self, $Serial$state state) {
     return self;
 }
 B_list B_listG_new(B_Iterable G_1, $WORD G_2) {
-    B_list $tmp = malloc(sizeof(struct B_list));
+    B_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_list), B_listG_methods.$GCdescr);
     $tmp->$class = &B_listG_methods;
     B_listG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 */
 struct B_listG_class B_listG_methods;
+GC_word B_listD_gcbm[GC_BITMAP_SIZE(struct B_list)];
 /*
 B_NoneType B_rangeD___init__ (B_range self, B_int start, B_int stop, B_int step);
 void B_rangeD___serialize__ (B_range self, $Serial$state state) {
@@ -223,7 +238,7 @@ void B_rangeD___serialize__ (B_range self, $Serial$state state) {
 B_range B_rangeD___deserialize__ (B_range self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_range));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_range), B_rangeG_methods.$GCdescr);
             self->$class = &B_rangeG_methods;
             return self;
         }
@@ -232,19 +247,20 @@ B_range B_rangeD___deserialize__ (B_range self, $Serial$state state) {
     return self;
 }
 B_range B_rangeG_new(B_int G_1, B_int G_2, B_int G_3) {
-    B_range $tmp = malloc(sizeof(struct B_range));
+    B_range $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_range), B_rangeG_methods.$GCdescr);
     $tmp->$class = &B_rangeG_methods;
     B_rangeG_methods.__init__($tmp, G_1, G_2, G_3);
     return $tmp;
 }
 */
 struct B_rangeG_class B_rangeG_methods;
+GC_word B_rangeD_gcbm[GC_BITMAP_SIZE(struct B_range)];
 void B_IteratorD___serialize__ (B_Iterator self, $Serial$state state) {
 }
 B_Iterator B_IteratorD___deserialize__ (B_Iterator self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Iterator));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Iterator), B_IteratorG_methods.$GCdescr);
             self->$class = &B_IteratorG_methods;
             return self;
         }
@@ -253,6 +269,7 @@ B_Iterator B_IteratorD___deserialize__ (B_Iterator self, $Serial$state state) {
     return self;
 }
 struct B_IteratorG_class B_IteratorG_methods;
+GC_word B_IteratorD_gcbm[GC_BITMAP_SIZE(struct B_Iterator)];
 B_NoneType B_IterableD___init__ (B_Iterable W_self) {
     return B_None;
 }
@@ -261,7 +278,7 @@ void B_IterableD___serialize__ (B_Iterable self, $Serial$state state) {
 B_Iterable B_IterableD___deserialize__ (B_Iterable self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Iterable));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Iterable), B_IterableG_methods.$GCdescr);
             self->$class = &B_IterableG_methods;
             return self;
         }
@@ -270,6 +287,7 @@ B_Iterable B_IterableD___deserialize__ (B_Iterable self, $Serial$state state) {
     return self;
 }
 struct B_IterableG_class B_IterableG_methods;
+GC_word B_IterableD_gcbm[GC_BITMAP_SIZE(struct B_Iterable)];
 B_NoneType B_strD___init__ (B_str self, B_value val);
 B_str B_strD_capitalize (B_str self);
 B_str B_strD_center (B_str self, B_int width, B_str fillchar);
@@ -311,7 +329,7 @@ void B_strD___serialize__ (B_str self, $Serial$state state) {
 B_str B_strD___deserialize__ (B_str self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_str));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_str), B_strG_methods.$GCdescr);
             self->$class = &B_strG_methods;
             return self;
         }
@@ -320,13 +338,14 @@ B_str B_strD___deserialize__ (B_str self, $Serial$state state) {
     return self;
 }
 B_str B_strG_new(B_value G_1) {
-    B_str $tmp = malloc(sizeof(struct B_str));
+    B_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_str), B_strG_methods.$GCdescr);
     $tmp->$class = &B_strG_methods;
     B_strG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 */
 struct B_strG_class B_strG_methods;
+GC_word B_strD_gcbm[GC_BITMAP_SIZE(struct B_str)];
 B_NoneType B_bytesD___init__ (B_bytes self, B_Iterable W_IterableE_226, $WORD iterable);
 B_bytes B_bytesD_capitalize (B_bytes self);
 B_bytes B_bytesD_center (B_bytes self, B_int width, B_bytes fillchar);
@@ -367,7 +386,7 @@ void B_bytesD___serialize__ (B_bytes self, $Serial$state state) {
 B_bytes B_bytesD___deserialize__ (B_bytes self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_bytes));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bytes), B_bytesG_methods.$GCdescr);
             self->$class = &B_bytesG_methods;
             return self;
         }
@@ -376,13 +395,14 @@ B_bytes B_bytesD___deserialize__ (B_bytes self, $Serial$state state) {
     return self;
 }
 B_bytes B_bytesG_new(B_Iterable G_1, $WORD G_2) {
-    B_bytes $tmp = malloc(sizeof(struct B_bytes));
+    B_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bytes), B_bytesG_methods.$GCdescr);
     $tmp->$class = &B_bytesG_methods;
     B_bytesG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 */
 struct B_bytesG_class B_bytesG_methods;
+GC_word B_bytesD_gcbm[GC_BITMAP_SIZE(struct B_bytes)];
 B_NoneType B_bytearrayD___init__ (B_bytearray self, B_bytes val);
 B_bytearray B_bytearrayD_capitalize (B_bytearray self);
 B_bytearray B_bytearrayD_center (B_bytearray self, B_int width, B_bytearray fillchar);
@@ -423,7 +443,7 @@ void B_bytearrayD___serialize__ (B_bytearray self, $Serial$state state) {
 B_bytearray B_bytearrayD___deserialize__ (B_bytearray self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_bytearray));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bytearray), B_bytearrayG_methods.$GCdescr);
             self->$class = &B_bytearrayG_methods;
             return self;
         }
@@ -432,20 +452,21 @@ B_bytearray B_bytearrayD___deserialize__ (B_bytearray self, $Serial$state state)
     return self;
 }
 B_bytearray B_bytearrayG_new(B_bytes G_1) {
-    B_bytearray $tmp = malloc(sizeof(struct B_bytearray));
+    B_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_bytearray), B_bytearrayG_methods.$GCdescr);
     $tmp->$class = &B_bytearrayG_methods;
     B_bytearrayG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 */
 struct B_bytearrayG_class B_bytearrayG_methods;
+GC_word B_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_bytearray)];
 /*
 void B_MsgD___serialize__ (B_Msg self, $Serial$state state) {
 }
 B_Msg B_MsgD___deserialize__ (B_Msg self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Msg));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Msg), B_MsgG_methods.$GCdescr);
             self->$class = &B_MsgG_methods;
             return self;
         }
@@ -454,12 +475,13 @@ B_Msg B_MsgD___deserialize__ (B_Msg self, $Serial$state state) {
     return self;
 }
 B_Msg B_MsgG_new() {
-    B_Msg $tmp = malloc(sizeof(struct B_Msg));
+    B_Msg $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Msg), B_MsgG_methods.$GCdescr);
     $tmp->$class = &B_MsgG_methods;
     B_MsgG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_MsgG_class B_MsgG_methods;
+GC_word B_MsgD_gcbm[GC_BITMAP_SIZE(struct B_Msg)];
 */
 B_NoneType B_BaseExceptionD___init__ (B_BaseException self, B_str msg) {
     self->error_message = msg;
@@ -471,7 +493,7 @@ void B_BaseExceptionD___serialize__ (B_BaseException self, $Serial$state state)
 B_BaseException B_BaseExceptionD___deserialize__ (B_BaseException self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_BaseException));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_BaseException), B_BaseExceptionG_methods.$GCdescr);
             self->$class = &B_BaseExceptionG_methods;
             return self;
         }
@@ -481,19 +503,20 @@ B_BaseException B_BaseExceptionD___deserialize__ (B_BaseException self, $Serial$
     return self;
 }
 B_BaseException B_BaseExceptionG_new(B_str G_1) {
-    B_BaseException $tmp = malloc(sizeof(struct B_BaseException));
+    B_BaseException $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_BaseException), B_BaseExceptionG_methods.$GCdescr);
     $tmp->$class = &B_BaseExceptionG_methods;
     B_BaseExceptionG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_BaseExceptionG_class B_BaseExceptionG_methods;
+GC_word B_BaseExceptionD_gcbm[GC_BITMAP_SIZE(struct B_BaseException)];
 void B_SystemExitD___serialize__ (B_SystemExit self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_SystemExit B_SystemExitD___deserialize__ (B_SystemExit self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_SystemExit));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SystemExit), B_SystemExitG_methods.$GCdescr);
             self->$class = &B_SystemExitG_methods;
             return self;
         }
@@ -503,19 +526,20 @@ B_SystemExit B_SystemExitD___deserialize__ (B_SystemExit self, $Serial$state sta
     return self;
 }
 B_SystemExit B_SystemExitG_new(B_str G_1) {
-    B_SystemExit $tmp = malloc(sizeof(struct B_SystemExit));
+    B_SystemExit $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SystemExit), B_SystemExitG_methods.$GCdescr);
     $tmp->$class = &B_SystemExitG_methods;
     B_SystemExitG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_SystemExitG_class B_SystemExitG_methods;
+GC_word B_SystemExitD_gcbm[GC_BITMAP_SIZE(struct B_SystemExit)];
 void B_KeyboardInterruptD___serialize__ (B_KeyboardInterrupt self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_KeyboardInterrupt B_KeyboardInterruptD___deserialize__ (B_KeyboardInterrupt self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_KeyboardInterrupt));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_KeyboardInterrupt), B_KeyboardInterruptG_methods.$GCdescr);
             self->$class = &B_KeyboardInterruptG_methods;
             return self;
         }
@@ -525,19 +549,20 @@ B_KeyboardInterrupt B_KeyboardInterruptD___deserialize__ (B_KeyboardInterrupt se
     return self;
 }
 B_KeyboardInterrupt B_KeyboardInterruptG_new(B_str G_1) {
-    B_KeyboardInterrupt $tmp = malloc(sizeof(struct B_KeyboardInterrupt));
+    B_KeyboardInterrupt $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_KeyboardInterrupt), B_KeyboardInterruptG_methods.$GCdescr);
     $tmp->$class = &B_KeyboardInterruptG_methods;
     B_KeyboardInterruptG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_KeyboardInterruptG_class B_KeyboardInterruptG_methods;
+GC_word B_KeyboardInterruptD_gcbm[GC_BITMAP_SIZE(struct B_KeyboardInterrupt)];
 void B_ExceptionD___serialize__ (B_Exception self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_Exception B_ExceptionD___deserialize__ (B_Exception self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Exception));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Exception), B_ExceptionG_methods.$GCdescr);
             self->$class = &B_ExceptionG_methods;
             return self;
         }
@@ -547,19 +572,20 @@ B_Exception B_ExceptionD___deserialize__ (B_Exception self, $Serial$state state)
     return self;
 }
 B_Exception B_ExceptionG_new(B_str G_1) {
-    B_Exception $tmp = malloc(sizeof(struct B_Exception));
+    B_Exception $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Exception), B_ExceptionG_methods.$GCdescr);
     $tmp->$class = &B_ExceptionG_methods;
     B_ExceptionG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_ExceptionG_class B_ExceptionG_methods;
+GC_word B_ExceptionD_gcbm[GC_BITMAP_SIZE(struct B_Exception)];
 void B_AssertionErrorD___serialize__ (B_AssertionError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_AssertionError B_AssertionErrorD___deserialize__ (B_AssertionError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_AssertionError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_AssertionError), B_AssertionErrorG_methods.$GCdescr);
             self->$class = &B_AssertionErrorG_methods;
             return self;
         }
@@ -569,19 +595,20 @@ B_AssertionError B_AssertionErrorD___deserialize__ (B_AssertionError self, $Seri
     return self;
 }
 B_AssertionError B_AssertionErrorG_new(B_str G_1) {
-    B_AssertionError $tmp = malloc(sizeof(struct B_AssertionError));
+    B_AssertionError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_AssertionError), B_AssertionErrorG_methods.$GCdescr);
     $tmp->$class = &B_AssertionErrorG_methods;
     B_AssertionErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_AssertionErrorG_class B_AssertionErrorG_methods;
+GC_word B_AssertionErrorD_gcbm[GC_BITMAP_SIZE(struct B_AssertionError)];
 void B_LookupErrorD___serialize__ (B_LookupError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_LookupError B_LookupErrorD___deserialize__ (B_LookupError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LookupError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LookupError), B_LookupErrorG_methods.$GCdescr);
             self->$class = &B_LookupErrorG_methods;
             return self;
         }
@@ -591,19 +618,20 @@ B_LookupError B_LookupErrorD___deserialize__ (B_LookupError self, $Serial$state
     return self;
 }
 B_LookupError B_LookupErrorG_new(B_str G_1) {
-    B_LookupError $tmp = malloc(sizeof(struct B_LookupError));
+    B_LookupError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LookupError), B_LookupErrorG_methods.$GCdescr);
     $tmp->$class = &B_LookupErrorG_methods;
     B_LookupErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_LookupErrorG_class B_LookupErrorG_methods;
+GC_word B_LookupErrorD_gcbm[GC_BITMAP_SIZE(struct B_LookupError)];
 void B_IndexErrorD___serialize__ (B_IndexError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_IndexError B_IndexErrorD___deserialize__ (B_IndexError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IndexError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexError), B_IndexErrorG_methods.$GCdescr);
             self->$class = &B_IndexErrorG_methods;
             return self;
         }
@@ -613,19 +641,20 @@ B_IndexError B_IndexErrorD___deserialize__ (B_IndexError self, $Serial$state sta
     return self;
 }
 B_IndexError B_IndexErrorG_new(B_str G_1) {
-    B_IndexError $tmp = malloc(sizeof(struct B_IndexError));
+    B_IndexError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexError), B_IndexErrorG_methods.$GCdescr);
     $tmp->$class = &B_IndexErrorG_methods;
     B_IndexErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_IndexErrorG_class B_IndexErrorG_methods;
+GC_word B_IndexErrorD_gcbm[GC_BITMAP_SIZE(struct B_IndexError)];
 void B_KeyErrorD___serialize__ (B_KeyError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_KeyError B_KeyErrorD___deserialize__ (B_KeyError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_KeyError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_KeyError), B_KeyErrorG_methods.$GCdescr);
             self->$class = &B_KeyErrorG_methods;
             return self;
         }
@@ -635,19 +664,20 @@ B_KeyError B_KeyErrorD___deserialize__ (B_KeyError self, $Serial$state state) {
     return self;
 }
 B_KeyError B_KeyErrorG_new(B_str G_1) {
-    B_KeyError $tmp = malloc(sizeof(struct B_KeyError));
+    B_KeyError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_KeyError), B_KeyErrorG_methods.$GCdescr);
     $tmp->$class = &B_KeyErrorG_methods;
     B_KeyErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_KeyErrorG_class B_KeyErrorG_methods;
+GC_word B_KeyErrorD_gcbm[GC_BITMAP_SIZE(struct B_KeyError)];
 void B_MemoryErrorD___serialize__ (B_MemoryError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_MemoryError B_MemoryErrorD___deserialize__ (B_MemoryError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MemoryError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MemoryError), B_MemoryErrorG_methods.$GCdescr);
             self->$class = &B_MemoryErrorG_methods;
             return self;
         }
@@ -657,19 +687,20 @@ B_MemoryError B_MemoryErrorD___deserialize__ (B_MemoryError self, $Serial$state
     return self;
 }
 B_MemoryError B_MemoryErrorG_new(B_str G_1) {
-    B_MemoryError $tmp = malloc(sizeof(struct B_MemoryError));
+    B_MemoryError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MemoryError), B_MemoryErrorG_methods.$GCdescr);
     $tmp->$class = &B_MemoryErrorG_methods;
     B_MemoryErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MemoryErrorG_class B_MemoryErrorG_methods;
+GC_word B_MemoryErrorD_gcbm[GC_BITMAP_SIZE(struct B_MemoryError)];
 void B_OSErrorD___serialize__ (B_OSError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_OSError B_OSErrorD___deserialize__ (B_OSError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OSError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OSError), B_OSErrorG_methods.$GCdescr);
             self->$class = &B_OSErrorG_methods;
             return self;
         }
@@ -679,19 +710,20 @@ B_OSError B_OSErrorD___deserialize__ (B_OSError self, $Serial$state state) {
     return self;
 }
 B_OSError B_OSErrorG_new(B_str G_1) {
-    B_OSError $tmp = malloc(sizeof(struct B_OSError));
+    B_OSError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OSError), B_OSErrorG_methods.$GCdescr);
     $tmp->$class = &B_OSErrorG_methods;
     B_OSErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_OSErrorG_class B_OSErrorG_methods;
+GC_word B_OSErrorD_gcbm[GC_BITMAP_SIZE(struct B_OSError)];
 void B_RuntimeErrorD___serialize__ (B_RuntimeError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_RuntimeError B_RuntimeErrorD___deserialize__ (B_RuntimeError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_RuntimeError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RuntimeError), B_RuntimeErrorG_methods.$GCdescr);
             self->$class = &B_RuntimeErrorG_methods;
             return self;
         }
@@ -701,19 +733,20 @@ B_RuntimeError B_RuntimeErrorD___deserialize__ (B_RuntimeError self, $Serial$sta
     return self;
 }
 B_RuntimeError B_RuntimeErrorG_new(B_str G_1) {
-    B_RuntimeError $tmp = malloc(sizeof(struct B_RuntimeError));
+    B_RuntimeError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RuntimeError), B_RuntimeErrorG_methods.$GCdescr);
     $tmp->$class = &B_RuntimeErrorG_methods;
     B_RuntimeErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_RuntimeErrorG_class B_RuntimeErrorG_methods;
+GC_word B_RuntimeErrorD_gcbm[GC_BITMAP_SIZE(struct B_RuntimeError)];
 void B_NotImplementedErrorD___serialize__ (B_NotImplementedError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_NotImplementedError B_NotImplementedErrorD___deserialize__ (B_NotImplementedError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_NotImplementedError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_NotImplementedError), B_NotImplementedErrorG_methods.$GCdescr);
             self->$class = &B_NotImplementedErrorG_methods;
             return self;
         }
@@ -723,19 +756,20 @@ B_NotImplementedError B_NotImplementedErrorD___deserialize__ (B_NotImplementedEr
     return self;
 }
 B_NotImplementedError B_NotImplementedErrorG_new(B_str G_1) {
-    B_NotImplementedError $tmp = malloc(sizeof(struct B_NotImplementedError));
+    B_NotImplementedError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_NotImplementedError), B_NotImplementedErrorG_methods.$GCdescr);
     $tmp->$class = &B_NotImplementedErrorG_methods;
     B_NotImplementedErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_NotImplementedErrorG_class B_NotImplementedErrorG_methods;
+GC_word B_NotImplementedErrorD_gcbm[GC_BITMAP_SIZE(struct B_NotImplementedError)];
 void B_ValueErrorD___serialize__ (B_ValueError self, $Serial$state state) {
     $step_serialize(self->error_message, state);
 }
 B_ValueError B_ValueErrorD___deserialize__ (B_ValueError self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_ValueError));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ValueError), B_ValueErrorG_methods.$GCdescr);
             self->$class = &B_ValueErrorG_methods;
             return self;
         }
@@ -745,12 +779,13 @@ B_ValueError B_ValueErrorD___deserialize__ (B_ValueError self, $Serial$state sta
     return self;
 }
 B_ValueError B_ValueErrorG_new(B_str G_1) {
-    B_ValueError $tmp = malloc(sizeof(struct B_ValueError));
+    B_ValueError $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ValueError), B_ValueErrorG_methods.$GCdescr);
     $tmp->$class = &B_ValueErrorG_methods;
     B_ValueErrorG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_ValueErrorG_class B_ValueErrorG_methods;
+GC_word B_ValueErrorD_gcbm[GC_BITMAP_SIZE(struct B_ValueError)];
 B_NoneType B_IdentityD___init__ (B_Identity W_self) {
     return B_None;
 }
@@ -759,7 +794,7 @@ void B_IdentityD___serialize__ (B_Identity self, $Serial$state state) {
 B_Identity B_IdentityD___deserialize__ (B_Identity self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Identity));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Identity), B_IdentityG_methods.$GCdescr);
             self->$class = &B_IdentityG_methods;
             return self;
         }
@@ -768,6 +803,7 @@ B_Identity B_IdentityD___deserialize__ (B_Identity self, $Serial$state state) {
     return self;
 }
 struct B_IdentityG_class B_IdentityG_methods;
+GC_word B_IdentityD_gcbm[GC_BITMAP_SIZE(struct B_Identity)];
 B_NoneType B_EqD___init__ (B_Eq W_self) {
     return B_None;
 }
@@ -779,7 +815,7 @@ void B_EqD___serialize__ (B_Eq self, $Serial$state state) {
 B_Eq B_EqD___deserialize__ (B_Eq self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Eq));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Eq), B_EqG_methods.$GCdescr);
             self->$class = &B_EqG_methods;
             return self;
         }
@@ -788,6 +824,7 @@ B_Eq B_EqD___deserialize__ (B_Eq self, $Serial$state state) {
     return self;
 }
 struct B_EqG_class B_EqG_methods;
+GC_word B_EqD_gcbm[GC_BITMAP_SIZE(struct B_Eq)];
 B_NoneType B_OrdD___init__ (B_Ord W_self) {
     ((B_NoneType (*) (B_Eq))B_EqG_methods.__init__)(((B_Eq)W_self));
     return B_None;
@@ -806,7 +843,7 @@ void B_OrdD___serialize__ (B_Ord self, $Serial$state state) {
 B_Ord B_OrdD___deserialize__ (B_Ord self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Ord));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Ord), B_OrdG_methods.$GCdescr);
             self->$class = &B_OrdG_methods;
             return self;
         }
@@ -815,6 +852,7 @@ B_Ord B_OrdD___deserialize__ (B_Ord self, $Serial$state state) {
     return self;
 }
 struct B_OrdG_class B_OrdG_methods;
+GC_word B_OrdD_gcbm[GC_BITMAP_SIZE(struct B_Ord)];
 B_NoneType B_LogicalD___init__ (B_Logical W_self) {
     return B_None;
 }
@@ -832,7 +870,7 @@ void B_LogicalD___serialize__ (B_Logical self, $Serial$state state) {
 B_Logical B_LogicalD___deserialize__ (B_Logical self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Logical));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Logical), B_LogicalG_methods.$GCdescr);
             self->$class = &B_LogicalG_methods;
             return self;
         }
@@ -841,6 +879,7 @@ B_Logical B_LogicalD___deserialize__ (B_Logical self, $Serial$state state) {
     return self;
 }
 struct B_LogicalG_class B_LogicalG_methods;
+GC_word B_LogicalD_gcbm[GC_BITMAP_SIZE(struct B_Logical)];
 B_NoneType B_PlusD___init__ (B_Plus W_self) {
     return B_None;
 }
@@ -852,7 +891,7 @@ void B_PlusD___serialize__ (B_Plus self, $Serial$state state) {
 B_Plus B_PlusD___deserialize__ (B_Plus self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Plus));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Plus), B_PlusG_methods.$GCdescr);
             self->$class = &B_PlusG_methods;
             return self;
         }
@@ -861,6 +900,7 @@ B_Plus B_PlusD___deserialize__ (B_Plus self, $Serial$state state) {
     return self;
 }
 struct B_PlusG_class B_PlusG_methods;
+GC_word B_PlusD_gcbm[GC_BITMAP_SIZE(struct B_Plus)];
 B_NoneType B_MinusD___init__ (B_Minus W_self) {
     return B_None;
 }
@@ -872,7 +912,7 @@ void B_MinusD___serialize__ (B_Minus self, $Serial$state state) {
 B_Minus B_MinusD___deserialize__ (B_Minus self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Minus));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Minus), B_MinusG_methods.$GCdescr);
             self->$class = &B_MinusG_methods;
             return self;
         }
@@ -881,6 +921,7 @@ B_Minus B_MinusD___deserialize__ (B_Minus self, $Serial$state state) {
     return self;
 }
 struct B_MinusG_class B_MinusG_methods;
+GC_word B_MinusD_gcbm[GC_BITMAP_SIZE(struct B_Minus)];
 B_NoneType B_TimesD___init__ (B_Times W_self) {
     ((B_NoneType (*) (B_Plus))B_PlusG_methods.__init__)(((B_Plus)W_self));
     return B_None;
@@ -893,7 +934,7 @@ void B_TimesD___serialize__ (B_Times self, $Serial$state state) {
 B_Times B_TimesD___deserialize__ (B_Times self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Times));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Times), B_TimesG_methods.$GCdescr);
             self->$class = &B_TimesG_methods;
             return self;
         }
@@ -902,6 +943,7 @@ B_Times B_TimesD___deserialize__ (B_Times self, $Serial$state state) {
     return self;
 }
 struct B_TimesG_class B_TimesG_methods;
+GC_word B_TimesD_gcbm[GC_BITMAP_SIZE(struct B_Times)];
 B_NoneType B_DivD___init__ (B_Div W_self) {
     return B_None;
 }
@@ -913,7 +955,7 @@ void B_DivD___serialize__ (B_Div self, $Serial$state state) {
 B_Div B_DivD___deserialize__ (B_Div self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Div));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Div), B_DivG_methods.$GCdescr);
             self->$class = &B_DivG_methods;
             return self;
         }
@@ -922,6 +964,7 @@ B_Div B_DivD___deserialize__ (B_Div self, $Serial$state state) {
     return self;
 }
 struct B_DivG_class B_DivG_methods;
+GC_word B_DivD_gcbm[GC_BITMAP_SIZE(struct B_Div)];
 B_NoneType B_HashableD___init__ (B_Hashable W_self) {
     ((B_NoneType (*) (B_Eq))B_EqG_methods.__init__)(((B_Eq)W_self));
     return B_None;
@@ -931,7 +974,7 @@ void B_HashableD___serialize__ (B_Hashable self, $Serial$state state) {
 B_Hashable B_HashableD___deserialize__ (B_Hashable self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Hashable));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Hashable), B_HashableG_methods.$GCdescr);
             self->$class = &B_HashableG_methods;
             return self;
         }
@@ -940,6 +983,7 @@ B_Hashable B_HashableD___deserialize__ (B_Hashable self, $Serial$state state) {
     return self;
 }
 struct B_HashableG_class B_HashableG_methods;
+GC_word B_HashableD_gcbm[GC_BITMAP_SIZE(struct B_Hashable)];
 /*
 B_NoneType B_complexD___init__ (B_complex self, B_Number W_NumberE_604, $WORD val);
 void B_complexD___serialize__ (B_complex self, $Serial$state state) {
@@ -947,7 +991,7 @@ void B_complexD___serialize__ (B_complex self, $Serial$state state) {
 B_complex B_complexD___deserialize__ (B_complex self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_complex));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_complex), B_complexG_methods.$GCdescr);
             self->$class = &B_complexG_methods;
             return self;
         }
@@ -956,13 +1000,14 @@ B_complex B_complexD___deserialize__ (B_complex self, $Serial$state state) {
     return self;
 }
 B_complex B_complexG_new(B_Number G_1, $WORD G_2) {
-    B_complex $tmp = malloc(sizeof(struct B_complex));
+    B_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_complex), B_complexG_methods.$GCdescr);
     $tmp->$class = &B_complexG_methods;
     B_complexG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 */
 struct B_complexG_class B_complexG_methods;
+GC_word B_complexD_gcbm[GC_BITMAP_SIZE(struct B_complex)];
 /*
 B_NoneType B_dictD___init__ (B_dict self, B_Hashable W_HashableD_A, B_Iterable W_IterableE_609, $WORD iterable);
 void B_dictD___serialize__ (B_dict self, $Serial$state state) {
@@ -970,7 +1015,7 @@ void B_dictD___serialize__ (B_dict self, $Serial$state state) {
 B_dict B_dictD___deserialize__ (B_dict self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_dict));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_dict), B_dictG_methods.$GCdescr);
             self->$class = &B_dictG_methods;
             return self;
         }
@@ -979,13 +1024,14 @@ B_dict B_dictD___deserialize__ (B_dict self, $Serial$state state) {
     return self;
 }
 B_dict B_dictG_new(B_Hashable G_1, B_Iterable G_2, $WORD G_3) {
-    B_dict $tmp = malloc(sizeof(struct B_dict));
+    B_dict $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_dict), B_dictG_methods.$GCdescr);
     $tmp->$class = &B_dictG_methods;
     B_dictG_methods.__init__($tmp, G_1, G_2, G_3);
     return $tmp;
 }
 */
 struct B_dictG_class B_dictG_methods;
+GC_word B_dictD_gcbm[GC_BITMAP_SIZE(struct B_dict)];
 /*
 B_NoneType B_setD___init__ (B_set self, B_Hashable W_HashableD_A, B_Iterable W_IterableE_617, $WORD iterable);
 void B_setD___serialize__ (B_set self, $Serial$state state) {
@@ -993,7 +1039,7 @@ void B_setD___serialize__ (B_set self, $Serial$state state) {
 B_set B_setD___deserialize__ (B_set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_set), B_setG_methods.$GCdescr);
             self->$class = &B_setG_methods;
             return self;
         }
@@ -1002,13 +1048,14 @@ B_set B_setD___deserialize__ (B_set self, $Serial$state state) {
     return self;
 }
 B_set B_setG_new(B_Hashable G_1, B_Iterable G_2, $WORD G_3) {
-    B_set $tmp = malloc(sizeof(struct B_set));
+    B_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_set), B_setG_methods.$GCdescr);
     $tmp->$class = &B_setG_methods;
     B_setG_methods.__init__($tmp, G_1, G_2, G_3);
     return $tmp;
 }
 */
 struct B_setG_class B_setG_methods;
+GC_word B_setD_gcbm[GC_BITMAP_SIZE(struct B_set)];
 B_NoneType B_NumberD___init__ (B_Number W_self, B_Minus W_Minus) {
     ((B_NoneType (*) (B_Times))B_TimesG_methods.__init__)(((B_Times)W_self));
     W_self->W_Minus = W_Minus;
@@ -1023,7 +1070,7 @@ void B_NumberD___serialize__ (B_Number self, $Serial$state state) {
 B_Number B_NumberD___deserialize__ (B_Number self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Number));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Number), B_NumberG_methods.$GCdescr);
             self->$class = &B_NumberG_methods;
             return self;
         }
@@ -1033,6 +1080,7 @@ B_Number B_NumberD___deserialize__ (B_Number self, $Serial$state state) {
     return self;
 }
 struct B_NumberG_class B_NumberG_methods;
+GC_word B_NumberD_gcbm[GC_BITMAP_SIZE(struct B_Number)];
 B_NoneType B_MinusD_NumberD___init__ (B_MinusD_Number W_self, B_Number W_Number) {
     ((B_NoneType (*) (B_Minus))B_MinusG_methods.__init__)(((B_Minus)W_self));
     W_self->W_Number = W_Number;
@@ -1044,7 +1092,7 @@ void B_MinusD_NumberD___serialize__ (B_MinusD_Number self, $Serial$state state)
 B_MinusD_Number B_MinusD_NumberD___deserialize__ (B_MinusD_Number self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_Number));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Number), B_MinusD_NumberG_methods.$GCdescr);
             self->$class = &B_MinusD_NumberG_methods;
             return self;
         }
@@ -1054,6 +1102,7 @@ B_MinusD_Number B_MinusD_NumberD___deserialize__ (B_MinusD_Number self, $Serial$
     return self;
 }
 struct B_MinusD_NumberG_class B_MinusD_NumberG_methods;
+GC_word B_MinusD_NumberD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Number)];
 B_NoneType B_RealD___init__ (B_Real W_self, B_Minus W_Minus) {
     ((B_NoneType (*) (B_Number, B_Minus))B_NumberG_methods.__init__)(((B_Number)W_self), W_Minus);
     return B_None;
@@ -1064,7 +1113,7 @@ void B_RealD___serialize__ (B_Real self, $Serial$state state) {
 B_Real B_RealD___deserialize__ (B_Real self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Real));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Real), B_RealG_methods.$GCdescr);
             self->$class = &B_RealG_methods;
             return self;
         }
@@ -1074,6 +1123,7 @@ B_Real B_RealD___deserialize__ (B_Real self, $Serial$state state) {
     return self;
 }
 struct B_RealG_class B_RealG_methods;
+GC_word B_RealD_gcbm[GC_BITMAP_SIZE(struct B_Real)];
 B_NoneType B_MinusD_RealD___init__ (B_MinusD_Real W_self, B_Real W_Real) {
     ((B_NoneType (*) (B_MinusD_Number, B_Number))B_MinusD_NumberG_methods.__init__)(((B_MinusD_Number)W_self), ((B_Number)W_Real));
     W_self->W_Real = W_Real;
@@ -1086,7 +1136,7 @@ void B_MinusD_RealD___serialize__ (B_MinusD_Real self, $Serial$state state) {
 B_MinusD_Real B_MinusD_RealD___deserialize__ (B_MinusD_Real self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_Real));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Real), B_MinusD_RealG_methods.$GCdescr);
             self->$class = &B_MinusD_RealG_methods;
             return self;
         }
@@ -1097,6 +1147,7 @@ B_MinusD_Real B_MinusD_RealD___deserialize__ (B_MinusD_Real self, $Serial$state
     return self;
 }
 struct B_MinusD_RealG_class B_MinusD_RealG_methods;
+GC_word B_MinusD_RealD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Real)];
 B_NoneType B_RealFloatD___init__ (B_RealFloat W_self, B_Minus W_Minus) {
     ((B_NoneType (*) (B_Real, B_Minus))B_RealG_methods.__init__)(((B_Real)W_self), W_Minus);
     return B_None;
@@ -1107,7 +1158,7 @@ void B_RealFloatD___serialize__ (B_RealFloat self, $Serial$state state) {
 B_RealFloat B_RealFloatD___deserialize__ (B_RealFloat self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_RealFloat));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RealFloat), B_RealFloatG_methods.$GCdescr);
             self->$class = &B_RealFloatG_methods;
             return self;
         }
@@ -1117,6 +1168,7 @@ B_RealFloat B_RealFloatD___deserialize__ (B_RealFloat self, $Serial$state state)
     return self;
 }
 struct B_RealFloatG_class B_RealFloatG_methods;
+GC_word B_RealFloatD_gcbm[GC_BITMAP_SIZE(struct B_RealFloat)];
 B_NoneType B_MinusD_RealFloatD___init__ (B_MinusD_RealFloat W_self, B_RealFloat W_RealFloat) {
     ((B_NoneType (*) (B_MinusD_Real, B_Real))B_MinusD_RealG_methods.__init__)(((B_MinusD_Real)W_self), ((B_Real)W_RealFloat));
     W_self->W_RealFloat = W_RealFloat;
@@ -1130,7 +1182,7 @@ void B_MinusD_RealFloatD___serialize__ (B_MinusD_RealFloat self, $Serial$state s
 B_MinusD_RealFloat B_MinusD_RealFloatD___deserialize__ (B_MinusD_RealFloat self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_RealFloat));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_RealFloat), B_MinusD_RealFloatG_methods.$GCdescr);
             self->$class = &B_MinusD_RealFloatG_methods;
             return self;
         }
@@ -1142,6 +1194,7 @@ B_MinusD_RealFloat B_MinusD_RealFloatD___deserialize__ (B_MinusD_RealFloat self,
     return self;
 }
 struct B_MinusD_RealFloatG_class B_MinusD_RealFloatG_methods;
+GC_word B_MinusD_RealFloatD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_RealFloat)];
 B_NoneType B_RationalD___init__ (B_Rational W_self, B_Minus W_Minus) {
     ((B_NoneType (*) (B_Real, B_Minus))B_RealG_methods.__init__)(((B_Real)W_self), W_Minus);
     return B_None;
@@ -1152,7 +1205,7 @@ void B_RationalD___serialize__ (B_Rational self, $Serial$state state) {
 B_Rational B_RationalD___deserialize__ (B_Rational self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Rational));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Rational), B_RationalG_methods.$GCdescr);
             self->$class = &B_RationalG_methods;
             return self;
         }
@@ -1162,6 +1215,7 @@ B_Rational B_RationalD___deserialize__ (B_Rational self, $Serial$state state) {
     return self;
 }
 struct B_RationalG_class B_RationalG_methods;
+GC_word B_RationalD_gcbm[GC_BITMAP_SIZE(struct B_Rational)];
 B_NoneType B_MinusD_RationalD___init__ (B_MinusD_Rational W_self, B_Rational W_Rational) {
     ((B_NoneType (*) (B_MinusD_Real, B_Real))B_MinusD_RealG_methods.__init__)(((B_MinusD_Real)W_self), ((B_Real)W_Rational));
     W_self->W_Rational = W_Rational;
@@ -1175,7 +1229,7 @@ void B_MinusD_RationalD___serialize__ (B_MinusD_Rational self, $Serial$state sta
 B_MinusD_Rational B_MinusD_RationalD___deserialize__ (B_MinusD_Rational self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_Rational));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Rational), B_MinusD_RationalG_methods.$GCdescr);
             self->$class = &B_MinusD_RationalG_methods;
             return self;
         }
@@ -1187,6 +1241,7 @@ B_MinusD_Rational B_MinusD_RationalD___deserialize__ (B_MinusD_Rational self, $S
     return self;
 }
 struct B_MinusD_RationalG_class B_MinusD_RationalG_methods;
+GC_word B_MinusD_RationalD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Rational)];
 B_NoneType B_IntegralD___init__ (B_Integral W_self, B_Minus W_Minus, B_Logical W_Logical) {
     ((B_NoneType (*) (B_Rational, B_Minus))B_RationalG_methods.__init__)(((B_Rational)W_self), W_Minus);
     W_self->W_Logical = W_Logical;
@@ -1211,7 +1266,7 @@ void B_IntegralD___serialize__ (B_Integral self, $Serial$state state) {
 B_Integral B_IntegralD___deserialize__ (B_Integral self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Integral));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Integral), B_IntegralG_methods.$GCdescr);
             self->$class = &B_IntegralG_methods;
             return self;
         }
@@ -1222,6 +1277,7 @@ B_Integral B_IntegralD___deserialize__ (B_Integral self, $Serial$state state) {
     return self;
 }
 struct B_IntegralG_class B_IntegralG_methods;
+GC_word B_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_Integral)];
 B_NoneType B_MinusD_IntegralD___init__ (B_MinusD_Integral W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_MinusD_Rational, B_Rational))B_MinusD_RationalG_methods.__init__)(((B_MinusD_Rational)W_self), ((B_Rational)W_Integral));
     W_self->W_Integral = W_Integral;
@@ -1236,7 +1292,7 @@ void B_MinusD_IntegralD___serialize__ (B_MinusD_Integral self, $Serial$state sta
 B_MinusD_Integral B_MinusD_IntegralD___deserialize__ (B_MinusD_Integral self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_Integral));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Integral), B_MinusD_IntegralG_methods.$GCdescr);
             self->$class = &B_MinusD_IntegralG_methods;
             return self;
         }
@@ -1249,6 +1305,7 @@ B_MinusD_Integral B_MinusD_IntegralD___deserialize__ (B_MinusD_Integral self, $S
     return self;
 }
 struct B_MinusD_IntegralG_class B_MinusD_IntegralG_methods;
+GC_word B_MinusD_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Integral)];
 B_NoneType B_LogicalD_IntegralD___init__ (B_LogicalD_Integral W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_Logical))B_LogicalG_methods.__init__)(((B_Logical)W_self));
     W_self->W_Integral = W_Integral;
@@ -1260,7 +1317,7 @@ void B_LogicalD_IntegralD___serialize__ (B_LogicalD_Integral self, $Serial$state
 B_LogicalD_Integral B_LogicalD_IntegralD___deserialize__ (B_LogicalD_Integral self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_Integral));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_Integral), B_LogicalD_IntegralG_methods.$GCdescr);
             self->$class = &B_LogicalD_IntegralG_methods;
             return self;
         }
@@ -1270,6 +1327,7 @@ B_LogicalD_Integral B_LogicalD_IntegralD___deserialize__ (B_LogicalD_Integral se
     return self;
 }
 struct B_LogicalD_IntegralG_class B_LogicalD_IntegralG_methods;
+GC_word B_LogicalD_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_Integral)];
 B_NoneType B_HashableD_boolD___init__ (B_HashableD_bool W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -1281,7 +1339,7 @@ void B_HashableD_boolD___serialize__ (B_HashableD_bool self, $Serial$state state
 B_HashableD_bool B_HashableD_boolD___deserialize__ (B_HashableD_bool self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_bool));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_bool), B_HashableD_boolG_methods.$GCdescr);
             self->$class = &B_HashableD_boolG_methods;
             return self;
         }
@@ -1290,12 +1348,13 @@ B_HashableD_bool B_HashableD_boolD___deserialize__ (B_HashableD_bool self, $Seri
     return self;
 }
 B_HashableD_bool B_HashableD_boolG_new() {
-    B_HashableD_bool $tmp = malloc(sizeof(struct B_HashableD_bool));
+    B_HashableD_bool $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_bool), B_HashableD_boolG_methods.$GCdescr);
     $tmp->$class = &B_HashableD_boolG_methods;
     B_HashableD_boolG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_HashableD_boolG_class B_HashableD_boolG_methods;
+GC_word B_HashableD_boolD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_bool)];
 B_NoneType B_IntegralD_intD___init__ (B_IntegralD_int W_self) {
     ((B_NoneType (*) (B_Integral, B_Minus, B_Logical))B_IntegralG_methods.__init__)(((B_Integral)W_self), ((B_Minus)B_MinusD_IntegralD_intG_new(((B_Integral)W_self))), ((B_Logical)B_LogicalD_IntegralD_intG_new(((B_Integral)W_self))));
     return B_None;
@@ -1333,7 +1392,7 @@ void B_IntegralD_intD___serialize__ (B_IntegralD_int self, $Serial$state state)
 B_IntegralD_int B_IntegralD_intD___deserialize__ (B_IntegralD_int self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IntegralD_int));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_int), B_IntegralD_intG_methods.$GCdescr);
             self->$class = &B_IntegralD_intG_methods;
             return self;
         }
@@ -1344,12 +1403,13 @@ B_IntegralD_int B_IntegralD_intD___deserialize__ (B_IntegralD_int self, $Serial$
     return self;
 }
 B_IntegralD_int B_IntegralD_intG_new() {
-    B_IntegralD_int $tmp = malloc(sizeof(struct B_IntegralD_int));
+    B_IntegralD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_int), B_IntegralD_intG_methods.$GCdescr);
     $tmp->$class = &B_IntegralD_intG_methods;
     B_IntegralD_intG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IntegralD_intG_class B_IntegralD_intG_methods;
+GC_word B_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_int)];
 B_NoneType B_MinusD_IntegralD_intD___init__ (B_MinusD_IntegralD_int W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -1364,7 +1424,7 @@ void B_MinusD_IntegralD_intD___serialize__ (B_MinusD_IntegralD_int self, $Serial
 B_MinusD_IntegralD_int B_MinusD_IntegralD_intD___deserialize__ (B_MinusD_IntegralD_int self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_IntegralD_int));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_int), B_MinusD_IntegralD_intG_methods.$GCdescr);
             self->$class = &B_MinusD_IntegralD_intG_methods;
             return self;
         }
@@ -1377,12 +1437,13 @@ B_MinusD_IntegralD_int B_MinusD_IntegralD_intD___deserialize__ (B_MinusD_Integra
     return self;
 }
 B_MinusD_IntegralD_int B_MinusD_IntegralD_intG_new(B_Integral G_1) {
-    B_MinusD_IntegralD_int $tmp = malloc(sizeof(struct B_MinusD_IntegralD_int));
+    B_MinusD_IntegralD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_int), B_MinusD_IntegralD_intG_methods.$GCdescr);
     $tmp->$class = &B_MinusD_IntegralD_intG_methods;
     B_MinusD_IntegralD_intG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_IntegralD_intG_class B_MinusD_IntegralD_intG_methods;
+GC_word B_MinusD_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_int)];
 B_NoneType B_LogicalD_IntegralD_intD___init__ (B_LogicalD_IntegralD_int W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -1396,7 +1457,7 @@ void B_LogicalD_IntegralD_intD___serialize__ (B_LogicalD_IntegralD_int self, $Se
 B_LogicalD_IntegralD_int B_LogicalD_IntegralD_intD___deserialize__ (B_LogicalD_IntegralD_int self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_IntegralD_int));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_int), B_LogicalD_IntegralD_intG_methods.$GCdescr);
             self->$class = &B_LogicalD_IntegralD_intG_methods;
             return self;
         }
@@ -1406,12 +1467,13 @@ B_LogicalD_IntegralD_int B_LogicalD_IntegralD_intD___deserialize__ (B_LogicalD_I
     return self;
 }
 B_LogicalD_IntegralD_int B_LogicalD_IntegralD_intG_new(B_Integral G_1) {
-    B_LogicalD_IntegralD_int $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_int));
+    B_LogicalD_IntegralD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_int), B_LogicalD_IntegralD_intG_methods.$GCdescr);
     $tmp->$class = &B_LogicalD_IntegralD_intG_methods;
     B_LogicalD_IntegralD_intG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_LogicalD_IntegralD_intG_class B_LogicalD_IntegralD_intG_methods;
+GC_word B_LogicalD_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_int)];
 B_NoneType B_DivD_intD___init__ (B_DivD_int W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -1422,7 +1484,7 @@ void B_DivD_intD___serialize__ (B_DivD_int self, $Serial$state state) {
 B_DivD_int B_DivD_intD___deserialize__ (B_DivD_int self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_int));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_int), B_DivD_intG_methods.$GCdescr);
             self->$class = &B_DivD_intG_methods;
             return self;
         }
@@ -1431,12 +1493,13 @@ B_DivD_int B_DivD_intD___deserialize__ (B_DivD_int self, $Serial$state state) {
     return self;
 }
 B_DivD_int B_DivD_intG_new() {
-    B_DivD_int $tmp = malloc(sizeof(struct B_DivD_int));
+    B_DivD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_int), B_DivD_intG_methods.$GCdescr);
     $tmp->$class = &B_DivD_intG_methods;
     B_DivD_intG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_intG_class B_DivD_intG_methods;
+GC_word B_DivD_intD_gcbm[GC_BITMAP_SIZE(struct B_DivD_int)];
 B_NoneType B_OrdD_intD___init__ (B_OrdD_int W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -1448,7 +1511,7 @@ void B_OrdD_intD___serialize__ (B_OrdD_int self, $Serial$state state) {
 B_OrdD_int B_OrdD_intD___deserialize__ (B_OrdD_int self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_int));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_int), B_OrdD_intG_methods.$GCdescr);
             self->$class = &B_OrdD_intG_methods;
             return self;
         }
@@ -1457,12 +1520,13 @@ B_OrdD_int B_OrdD_intD___deserialize__ (B_OrdD_int self, $Serial$state state) {
     return self;
 }
 B_OrdD_int B_OrdD_intG_new() {
-    B_OrdD_int $tmp = malloc(sizeof(struct B_OrdD_int));
+    B_OrdD_int $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_int), B_OrdD_intG_methods.$GCdescr);
     $tmp->$class = &B_OrdD_intG_methods;
     B_OrdD_intG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_intG_class B_OrdD_intG_methods;
+GC_word B_OrdD_intD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_int)];
 B_NoneType B_HashableD_intD___init__ (B_HashableD_int W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -1473,7 +1537,7 @@ void B_HashableD_intD___serialize__ (B_HashableD_int self, $Serial$state state)
 B_HashableD_int B_HashableD_intD___deserialize__ (B_HashableD_int self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_int));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_int), B_HashableD_intG_methods.$GCdescr);
             self->$class = &B_HashableD_intG_methods;
             return self;
         }
@@ -1485,6 +1549,7 @@ B_HashableD_int B_HashableD_intG_new() {   // manually added
     return $NEW(B_HashableD_int);          //
 }                                          //
 struct B_HashableD_intG_class B_HashableD_intG_methods;
+GC_word B_HashableD_intD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_int)];
 
 
 
@@ -1534,7 +1599,7 @@ void B_IntegralD_i64D___serialize__ (B_IntegralD_i64 self, $Serial$state state)
 B_IntegralD_i64 B_IntegralD_i64D___deserialize__ (B_IntegralD_i64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IntegralD_i64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i64), B_IntegralD_i64G_methods.$GCdescr);
             self->$class = &B_IntegralD_i64G_methods;
             return self;
         }
@@ -1545,12 +1610,13 @@ B_IntegralD_i64 B_IntegralD_i64D___deserialize__ (B_IntegralD_i64 self, $Serial$
     return self;
 }
 B_IntegralD_i64 B_IntegralD_i64G_new() {
-    B_IntegralD_i64 $tmp = malloc(sizeof(struct B_IntegralD_i64));
+    B_IntegralD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i64), B_IntegralD_i64G_methods.$GCdescr);
     $tmp->$class = &B_IntegralD_i64G_methods;
     B_IntegralD_i64G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IntegralD_i64G_class B_IntegralD_i64G_methods;
+GC_word B_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i64)];
 B_NoneType B_MinusD_IntegralD_i64D___init__ (B_MinusD_IntegralD_i64 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -1565,7 +1631,7 @@ void B_MinusD_IntegralD_i64D___serialize__ (B_MinusD_IntegralD_i64 self, $Serial
 B_MinusD_IntegralD_i64 B_MinusD_IntegralD_i64D___deserialize__ (B_MinusD_IntegralD_i64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_IntegralD_i64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i64), B_MinusD_IntegralD_i64G_methods.$GCdescr);
             self->$class = &B_MinusD_IntegralD_i64G_methods;
             return self;
         }
@@ -1578,12 +1644,13 @@ B_MinusD_IntegralD_i64 B_MinusD_IntegralD_i64D___deserialize__ (B_MinusD_Integra
     return self;
 }
 B_MinusD_IntegralD_i64 B_MinusD_IntegralD_i64G_new(B_Integral G_1) {
-    B_MinusD_IntegralD_i64 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_i64));
+    B_MinusD_IntegralD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i64), B_MinusD_IntegralD_i64G_methods.$GCdescr);
     $tmp->$class = &B_MinusD_IntegralD_i64G_methods;
     B_MinusD_IntegralD_i64G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_IntegralD_i64G_class B_MinusD_IntegralD_i64G_methods;
+GC_word B_MinusD_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i64)];
 B_NoneType B_LogicalD_IntegralD_i64D___init__ (B_LogicalD_IntegralD_i64 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -1597,7 +1664,7 @@ void B_LogicalD_IntegralD_i64D___serialize__ (B_LogicalD_IntegralD_i64 self, $Se
 B_LogicalD_IntegralD_i64 B_LogicalD_IntegralD_i64D___deserialize__ (B_LogicalD_IntegralD_i64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_IntegralD_i64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i64), B_LogicalD_IntegralD_i64G_methods.$GCdescr);
             self->$class = &B_LogicalD_IntegralD_i64G_methods;
             return self;
         }
@@ -1607,12 +1674,13 @@ B_LogicalD_IntegralD_i64 B_LogicalD_IntegralD_i64D___deserialize__ (B_LogicalD_I
     return self;
 }
 B_LogicalD_IntegralD_i64 B_LogicalD_IntegralD_i64G_new(B_Integral G_1) {
-    B_LogicalD_IntegralD_i64 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_i64));
+    B_LogicalD_IntegralD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i64), B_LogicalD_IntegralD_i64G_methods.$GCdescr);
     $tmp->$class = &B_LogicalD_IntegralD_i64G_methods;
     B_LogicalD_IntegralD_i64G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_LogicalD_IntegralD_i64G_class B_LogicalD_IntegralD_i64G_methods;
+GC_word B_LogicalD_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i64)];
 B_NoneType B_DivD_i64D___init__ (B_DivD_i64 W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -1623,7 +1691,7 @@ void B_DivD_i64D___serialize__ (B_DivD_i64 self, $Serial$state state) {
 B_DivD_i64 B_DivD_i64D___deserialize__ (B_DivD_i64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_i64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i64), B_DivD_i64G_methods.$GCdescr);
             self->$class = &B_DivD_i64G_methods;
             return self;
         }
@@ -1632,12 +1700,13 @@ B_DivD_i64 B_DivD_i64D___deserialize__ (B_DivD_i64 self, $Serial$state state) {
     return self;
 }
 B_DivD_i64 B_DivD_i64G_new() {
-    B_DivD_i64 $tmp = malloc(sizeof(struct B_DivD_i64));
+    B_DivD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i64), B_DivD_i64G_methods.$GCdescr);
     $tmp->$class = &B_DivD_i64G_methods;
     B_DivD_i64G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_i64G_class B_DivD_i64G_methods;
+GC_word B_DivD_i64D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i64)];
 B_NoneType B_OrdD_i64D___init__ (B_OrdD_i64 W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -1649,7 +1718,7 @@ void B_OrdD_i64D___serialize__ (B_OrdD_i64 self, $Serial$state state) {
 B_OrdD_i64 B_OrdD_i64D___deserialize__ (B_OrdD_i64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_i64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i64), B_OrdD_i64G_methods.$GCdescr);
             self->$class = &B_OrdD_i64G_methods;
             return self;
         }
@@ -1658,12 +1727,13 @@ B_OrdD_i64 B_OrdD_i64D___deserialize__ (B_OrdD_i64 self, $Serial$state state) {
     return self;
 }
 B_OrdD_i64 B_OrdD_i64G_new() {
-    B_OrdD_i64 $tmp = malloc(sizeof(struct B_OrdD_i64));
+    B_OrdD_i64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i64), B_OrdD_i64G_methods.$GCdescr);
     $tmp->$class = &B_OrdD_i64G_methods;
     B_OrdD_i64G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_i64G_class B_OrdD_i64G_methods;
+GC_word B_OrdD_i64D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i64)];
 B_NoneType B_HashableD_i64D___init__ (B_HashableD_i64 W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -1674,7 +1744,7 @@ void B_HashableD_i64D___serialize__ (B_HashableD_i64 self, $Serial$state state)
 B_HashableD_i64 B_HashableD_i64D___deserialize__ (B_HashableD_i64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_i64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_i64), B_HashableD_i64G_methods.$GCdescr);
             self->$class = &B_HashableD_i64G_methods;
             return self;
         }
@@ -1686,6 +1756,7 @@ B_HashableD_i64 B_HashableD_i64G_new() {   // manually added
     return $NEW(B_HashableD_i64);          //
 }                                          //
 struct B_HashableD_i64G_class B_HashableD_i64G_methods;
+GC_word B_HashableD_i64D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i64)];
 
 
 
@@ -1734,7 +1805,7 @@ void B_IntegralD_i32D___serialize__ (B_IntegralD_i32 self, $Serial$state state)
 B_IntegralD_i32 B_IntegralD_i32D___deserialize__ (B_IntegralD_i32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IntegralD_i32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i32), B_IntegralD_i32G_methods.$GCdescr);
             self->$class = &B_IntegralD_i32G_methods;
             return self;
         }
@@ -1745,12 +1816,13 @@ B_IntegralD_i32 B_IntegralD_i32D___deserialize__ (B_IntegralD_i32 self, $Serial$
     return self;
 }
 B_IntegralD_i32 B_IntegralD_i32G_new() {
-    B_IntegralD_i32 $tmp = malloc(sizeof(struct B_IntegralD_i32));
+    B_IntegralD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i32), B_IntegralD_i32G_methods.$GCdescr);
     $tmp->$class = &B_IntegralD_i32G_methods;
     B_IntegralD_i32G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IntegralD_i32G_class B_IntegralD_i32G_methods;
+GC_word B_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i32)];
 B_NoneType B_MinusD_IntegralD_i32D___init__ (B_MinusD_IntegralD_i32 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -1765,7 +1837,7 @@ void B_MinusD_IntegralD_i32D___serialize__ (B_MinusD_IntegralD_i32 self, $Serial
 B_MinusD_IntegralD_i32 B_MinusD_IntegralD_i32D___deserialize__ (B_MinusD_IntegralD_i32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_IntegralD_i32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i32), B_MinusD_IntegralD_i32G_methods.$GCdescr);
             self->$class = &B_MinusD_IntegralD_i32G_methods;
             return self;
         }
@@ -1778,12 +1850,13 @@ B_MinusD_IntegralD_i32 B_MinusD_IntegralD_i32D___deserialize__ (B_MinusD_Integra
     return self;
 }
 B_MinusD_IntegralD_i32 B_MinusD_IntegralD_i32G_new(B_Integral G_1) {
-    B_MinusD_IntegralD_i32 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_i32));
+    B_MinusD_IntegralD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i32), B_MinusD_IntegralD_i32G_methods.$GCdescr);
     $tmp->$class = &B_MinusD_IntegralD_i32G_methods;
     B_MinusD_IntegralD_i32G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_IntegralD_i32G_class B_MinusD_IntegralD_i32G_methods;
+GC_word B_MinusD_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i32)];
 B_NoneType B_LogicalD_IntegralD_i32D___init__ (B_LogicalD_IntegralD_i32 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -1797,7 +1870,7 @@ void B_LogicalD_IntegralD_i32D___serialize__ (B_LogicalD_IntegralD_i32 self, $Se
 B_LogicalD_IntegralD_i32 B_LogicalD_IntegralD_i32D___deserialize__ (B_LogicalD_IntegralD_i32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_IntegralD_i32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i32), B_LogicalD_IntegralD_i32G_methods.$GCdescr);
             self->$class = &B_LogicalD_IntegralD_i32G_methods;
             return self;
         }
@@ -1807,12 +1880,13 @@ B_LogicalD_IntegralD_i32 B_LogicalD_IntegralD_i32D___deserialize__ (B_LogicalD_I
     return self;
 }
 B_LogicalD_IntegralD_i32 B_LogicalD_IntegralD_i32G_new(B_Integral G_1) {
-    B_LogicalD_IntegralD_i32 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_i32));
+    B_LogicalD_IntegralD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i32), B_LogicalD_IntegralD_i32G_methods.$GCdescr);
     $tmp->$class = &B_LogicalD_IntegralD_i32G_methods;
     B_LogicalD_IntegralD_i32G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_LogicalD_IntegralD_i32G_class B_LogicalD_IntegralD_i32G_methods;
+GC_word B_LogicalD_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i32)];
 B_NoneType B_DivD_i32D___init__ (B_DivD_i32 W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -1823,7 +1897,7 @@ void B_DivD_i32D___serialize__ (B_DivD_i32 self, $Serial$state state) {
 B_DivD_i32 B_DivD_i32D___deserialize__ (B_DivD_i32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_i32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i32), B_DivD_i32G_methods.$GCdescr);
             self->$class = &B_DivD_i32G_methods;
             return self;
         }
@@ -1832,12 +1906,13 @@ B_DivD_i32 B_DivD_i32D___deserialize__ (B_DivD_i32 self, $Serial$state state) {
     return self;
 }
 B_DivD_i32 B_DivD_i32G_new() {
-    B_DivD_i32 $tmp = malloc(sizeof(struct B_DivD_i32));
+    B_DivD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i32), B_DivD_i32G_methods.$GCdescr);
     $tmp->$class = &B_DivD_i32G_methods;
     B_DivD_i32G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_i32G_class B_DivD_i32G_methods;
+GC_word B_DivD_i32D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i32)];
 B_NoneType B_OrdD_i32D___init__ (B_OrdD_i32 W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -1849,7 +1924,7 @@ void B_OrdD_i32D___serialize__ (B_OrdD_i32 self, $Serial$state state) {
 B_OrdD_i32 B_OrdD_i32D___deserialize__ (B_OrdD_i32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_i32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i32), B_OrdD_i32G_methods.$GCdescr);
             self->$class = &B_OrdD_i32G_methods;
             return self;
         }
@@ -1858,12 +1933,13 @@ B_OrdD_i32 B_OrdD_i32D___deserialize__ (B_OrdD_i32 self, $Serial$state state) {
     return self;
 }
 B_OrdD_i32 B_OrdD_i32G_new() {
-    B_OrdD_i32 $tmp = malloc(sizeof(struct B_OrdD_i32));
+    B_OrdD_i32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i32), B_OrdD_i32G_methods.$GCdescr);
     $tmp->$class = &B_OrdD_i32G_methods;
     B_OrdD_i32G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_i32G_class B_OrdD_i32G_methods;
+GC_word B_OrdD_i32D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i32)];
 B_NoneType B_HashableD_i32D___init__ (B_HashableD_i32 W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -1874,7 +1950,7 @@ void B_HashableD_i32D___serialize__ (B_HashableD_i32 self, $Serial$state state)
 B_HashableD_i32 B_HashableD_i32D___deserialize__ (B_HashableD_i32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_i32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_i32), B_HashableD_i32G_methods.$GCdescr);
             self->$class = &B_HashableD_i32G_methods;
             return self;
         }
@@ -1886,6 +1962,7 @@ B_HashableD_i32 B_HashableD_i32G_new() {   // manually added
     return $NEW(B_HashableD_i32);          //
 }                                          //
 struct B_HashableD_i32G_class B_HashableD_i32G_methods;
+GC_word B_HashableD_i32D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i32)];
 
 
 
@@ -1934,7 +2011,7 @@ void B_IntegralD_i16D___serialize__ (B_IntegralD_i16 self, $Serial$state state)
 B_IntegralD_i16 B_IntegralD_i16D___deserialize__ (B_IntegralD_i16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IntegralD_i16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i16), B_IntegralD_i16G_methods.$GCdescr);
             self->$class = &B_IntegralD_i16G_methods;
             return self;
         }
@@ -1945,12 +2022,13 @@ B_IntegralD_i16 B_IntegralD_i16D___deserialize__ (B_IntegralD_i16 self, $Serial$
     return self;
 }
 B_IntegralD_i16 B_IntegralD_i16G_new() {
-    B_IntegralD_i16 $tmp = malloc(sizeof(struct B_IntegralD_i16));
+    B_IntegralD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_i16), B_IntegralD_i16G_methods.$GCdescr);
     $tmp->$class = &B_IntegralD_i16G_methods;
     B_IntegralD_i16G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IntegralD_i16G_class B_IntegralD_i16G_methods;
+GC_word B_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i16)];
 B_NoneType B_MinusD_IntegralD_i16D___init__ (B_MinusD_IntegralD_i16 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -1965,7 +2043,7 @@ void B_MinusD_IntegralD_i16D___serialize__ (B_MinusD_IntegralD_i16 self, $Serial
 B_MinusD_IntegralD_i16 B_MinusD_IntegralD_i16D___deserialize__ (B_MinusD_IntegralD_i16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_IntegralD_i16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i16), B_MinusD_IntegralD_i16G_methods.$GCdescr);
             self->$class = &B_MinusD_IntegralD_i16G_methods;
             return self;
         }
@@ -1978,12 +2056,13 @@ B_MinusD_IntegralD_i16 B_MinusD_IntegralD_i16D___deserialize__ (B_MinusD_Integra
     return self;
 }
 B_MinusD_IntegralD_i16 B_MinusD_IntegralD_i16G_new(B_Integral G_1) {
-    B_MinusD_IntegralD_i16 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_i16));
+    B_MinusD_IntegralD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_i16), B_MinusD_IntegralD_i16G_methods.$GCdescr);
     $tmp->$class = &B_MinusD_IntegralD_i16G_methods;
     B_MinusD_IntegralD_i16G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_IntegralD_i16G_class B_MinusD_IntegralD_i16G_methods;
+GC_word B_MinusD_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i16)];
 B_NoneType B_LogicalD_IntegralD_i16D___init__ (B_LogicalD_IntegralD_i16 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -1997,7 +2076,7 @@ void B_LogicalD_IntegralD_i16D___serialize__ (B_LogicalD_IntegralD_i16 self, $Se
 B_LogicalD_IntegralD_i16 B_LogicalD_IntegralD_i16D___deserialize__ (B_LogicalD_IntegralD_i16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_IntegralD_i16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i16), B_LogicalD_IntegralD_i16G_methods.$GCdescr);
             self->$class = &B_LogicalD_IntegralD_i16G_methods;
             return self;
         }
@@ -2007,12 +2086,13 @@ B_LogicalD_IntegralD_i16 B_LogicalD_IntegralD_i16D___deserialize__ (B_LogicalD_I
     return self;
 }
 B_LogicalD_IntegralD_i16 B_LogicalD_IntegralD_i16G_new(B_Integral G_1) {
-    B_LogicalD_IntegralD_i16 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_i16));
+    B_LogicalD_IntegralD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_i16), B_LogicalD_IntegralD_i16G_methods.$GCdescr);
     $tmp->$class = &B_LogicalD_IntegralD_i16G_methods;
     B_LogicalD_IntegralD_i16G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_LogicalD_IntegralD_i16G_class B_LogicalD_IntegralD_i16G_methods;
+GC_word B_LogicalD_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i16)];
 B_NoneType B_DivD_i16D___init__ (B_DivD_i16 W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -2023,7 +2103,7 @@ void B_DivD_i16D___serialize__ (B_DivD_i16 self, $Serial$state state) {
 B_DivD_i16 B_DivD_i16D___deserialize__ (B_DivD_i16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_i16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i16), B_DivD_i16G_methods.$GCdescr);
             self->$class = &B_DivD_i16G_methods;
             return self;
         }
@@ -2032,12 +2112,13 @@ B_DivD_i16 B_DivD_i16D___deserialize__ (B_DivD_i16 self, $Serial$state state) {
     return self;
 }
 B_DivD_i16 B_DivD_i16G_new() {
-    B_DivD_i16 $tmp = malloc(sizeof(struct B_DivD_i16));
+    B_DivD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_i16), B_DivD_i16G_methods.$GCdescr);
     $tmp->$class = &B_DivD_i16G_methods;
     B_DivD_i16G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_i16G_class B_DivD_i16G_methods;
+GC_word B_DivD_i16D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i16)];
 B_NoneType B_OrdD_i16D___init__ (B_OrdD_i16 W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -2049,7 +2130,7 @@ void B_OrdD_i16D___serialize__ (B_OrdD_i16 self, $Serial$state state) {
 B_OrdD_i16 B_OrdD_i16D___deserialize__ (B_OrdD_i16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_i16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i16), B_OrdD_i16G_methods.$GCdescr);
             self->$class = &B_OrdD_i16G_methods;
             return self;
         }
@@ -2058,12 +2139,13 @@ B_OrdD_i16 B_OrdD_i16D___deserialize__ (B_OrdD_i16 self, $Serial$state state) {
     return self;
 }
 B_OrdD_i16 B_OrdD_i16G_new() {
-    B_OrdD_i16 $tmp = malloc(sizeof(struct B_OrdD_i16));
+    B_OrdD_i16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_i16), B_OrdD_i16G_methods.$GCdescr);
     $tmp->$class = &B_OrdD_i16G_methods;
     B_OrdD_i16G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_i16G_class B_OrdD_i16G_methods;
+GC_word B_OrdD_i16D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i16)];
 B_NoneType B_HashableD_i16D___init__ (B_HashableD_i16 W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -2074,7 +2156,7 @@ void B_HashableD_i16D___serialize__ (B_HashableD_i16 self, $Serial$state state)
 B_HashableD_i16 B_HashableD_i16D___deserialize__ (B_HashableD_i16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_i16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_i16), B_HashableD_i16G_methods.$GCdescr);
             self->$class = &B_HashableD_i16G_methods;
             return self;
         }
@@ -2086,6 +2168,7 @@ B_HashableD_i16 B_HashableD_i16G_new() {   // manually added
     return $NEW(B_HashableD_i16);          //
 }                                          //
 struct B_HashableD_i16G_class B_HashableD_i16G_methods;
+GC_word B_HashableD_i16D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i16)];
 
 
 
@@ -2135,7 +2218,7 @@ void B_IntegralD_u64D___serialize__ (B_IntegralD_u64 self, $Serial$state state)
 B_IntegralD_u64 B_IntegralD_u64D___deserialize__ (B_IntegralD_u64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IntegralD_u64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u64), B_IntegralD_u64G_methods.$GCdescr);
             self->$class = &B_IntegralD_u64G_methods;
             return self;
         }
@@ -2146,12 +2229,13 @@ B_IntegralD_u64 B_IntegralD_u64D___deserialize__ (B_IntegralD_u64 self, $Serial$
     return self;
 }
 B_IntegralD_u64 B_IntegralD_u64G_new() {
-    B_IntegralD_u64 $tmp = malloc(sizeof(struct B_IntegralD_u64));
+    B_IntegralD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u64), B_IntegralD_u64G_methods.$GCdescr);
     $tmp->$class = &B_IntegralD_u64G_methods;
     B_IntegralD_u64G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IntegralD_u64G_class B_IntegralD_u64G_methods;
+GC_word B_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u64)];
 B_NoneType B_MinusD_IntegralD_u64D___init__ (B_MinusD_IntegralD_u64 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -2166,7 +2250,7 @@ void B_MinusD_IntegralD_u64D___serialize__ (B_MinusD_IntegralD_u64 self, $Serial
 B_MinusD_IntegralD_u64 B_MinusD_IntegralD_u64D___deserialize__ (B_MinusD_IntegralD_u64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_IntegralD_u64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u64), B_MinusD_IntegralD_u64G_methods.$GCdescr);
             self->$class = &B_MinusD_IntegralD_u64G_methods;
             return self;
         }
@@ -2179,12 +2263,13 @@ B_MinusD_IntegralD_u64 B_MinusD_IntegralD_u64D___deserialize__ (B_MinusD_Integra
     return self;
 }
 B_MinusD_IntegralD_u64 B_MinusD_IntegralD_u64G_new(B_Integral G_1) {
-    B_MinusD_IntegralD_u64 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_u64));
+    B_MinusD_IntegralD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u64), B_MinusD_IntegralD_u64G_methods.$GCdescr);
     $tmp->$class = &B_MinusD_IntegralD_u64G_methods;
     B_MinusD_IntegralD_u64G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_IntegralD_u64G_class B_MinusD_IntegralD_u64G_methods;
+GC_word B_MinusD_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u64)];
 B_NoneType B_LogicalD_IntegralD_u64D___init__ (B_LogicalD_IntegralD_u64 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -2198,7 +2283,7 @@ void B_LogicalD_IntegralD_u64D___serialize__ (B_LogicalD_IntegralD_u64 self, $Se
 B_LogicalD_IntegralD_u64 B_LogicalD_IntegralD_u64D___deserialize__ (B_LogicalD_IntegralD_u64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_IntegralD_u64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u64), B_LogicalD_IntegralD_u64G_methods.$GCdescr);
             self->$class = &B_LogicalD_IntegralD_u64G_methods;
             return self;
         }
@@ -2208,12 +2293,13 @@ B_LogicalD_IntegralD_u64 B_LogicalD_IntegralD_u64D___deserialize__ (B_LogicalD_I
     return self;
 }
 B_LogicalD_IntegralD_u64 B_LogicalD_IntegralD_u64G_new(B_Integral G_1) {
-    B_LogicalD_IntegralD_u64 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_u64));
+    B_LogicalD_IntegralD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u64), B_LogicalD_IntegralD_u64G_methods.$GCdescr);
     $tmp->$class = &B_LogicalD_IntegralD_u64G_methods;
     B_LogicalD_IntegralD_u64G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_LogicalD_IntegralD_u64G_class B_LogicalD_IntegralD_u64G_methods;
+GC_word B_LogicalD_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u64)];
 B_NoneType B_DivD_u64D___init__ (B_DivD_u64 W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -2224,7 +2310,7 @@ void B_DivD_u64D___serialize__ (B_DivD_u64 self, $Serial$state state) {
 B_DivD_u64 B_DivD_u64D___deserialize__ (B_DivD_u64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_u64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u64), B_DivD_u64G_methods.$GCdescr);
             self->$class = &B_DivD_u64G_methods;
             return self;
         }
@@ -2236,12 +2322,13 @@ B_HashableD_u64 B_HashableD_u64G_new() {   // manually added
     return $NEW(B_HashableD_u64);          //
 }                                          //
 B_DivD_u64 B_DivD_u64G_new() {
-    B_DivD_u64 $tmp = malloc(sizeof(struct B_DivD_u64));
+    B_DivD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u64), B_DivD_u64G_methods.$GCdescr);
     $tmp->$class = &B_DivD_u64G_methods;
     B_DivD_u64G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_u64G_class B_DivD_u64G_methods;
+GC_word B_DivD_u64D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u64)];
 B_NoneType B_OrdD_u64D___init__ (B_OrdD_u64 W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -2253,7 +2340,7 @@ void B_OrdD_u64D___serialize__ (B_OrdD_u64 self, $Serial$state state) {
 B_OrdD_u64 B_OrdD_u64D___deserialize__ (B_OrdD_u64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_u64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u64), B_OrdD_u64G_methods.$GCdescr);
             self->$class = &B_OrdD_u64G_methods;
             return self;
         }
@@ -2262,12 +2349,13 @@ B_OrdD_u64 B_OrdD_u64D___deserialize__ (B_OrdD_u64 self, $Serial$state state) {
     return self;
 }
 B_OrdD_u64 B_OrdD_u64G_new() {
-    B_OrdD_u64 $tmp = malloc(sizeof(struct B_OrdD_u64));
+    B_OrdD_u64 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u64), B_OrdD_u64G_methods.$GCdescr);
     $tmp->$class = &B_OrdD_u64G_methods;
     B_OrdD_u64G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_u64G_class B_OrdD_u64G_methods;
+GC_word B_OrdD_u64D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u64)];
 B_NoneType B_HashableD_u64D___init__ (B_HashableD_u64 W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -2278,7 +2366,7 @@ void B_HashableD_u64D___serialize__ (B_HashableD_u64 self, $Serial$state state)
 B_HashableD_u64 B_HashableD_u64D___deserialize__ (B_HashableD_u64 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_u64));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_u64), B_HashableD_u64G_methods.$GCdescr);
             self->$class = &B_HashableD_u64G_methods;
             return self;
         }
@@ -2287,6 +2375,7 @@ B_HashableD_u64 B_HashableD_u64D___deserialize__ (B_HashableD_u64 self, $Serial$
     return self;
 }
 struct B_HashableD_u64G_class B_HashableD_u64G_methods;
+GC_word B_HashableD_u64D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u64)];
 
 
 
@@ -2334,7 +2423,7 @@ void B_IntegralD_u32D___serialize__ (B_IntegralD_u32 self, $Serial$state state)
 B_IntegralD_u32 B_IntegralD_u32D___deserialize__ (B_IntegralD_u32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IntegralD_u32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u32), B_IntegralD_u32G_methods.$GCdescr);
             self->$class = &B_IntegralD_u32G_methods;
             return self;
         }
@@ -2345,12 +2434,13 @@ B_IntegralD_u32 B_IntegralD_u32D___deserialize__ (B_IntegralD_u32 self, $Serial$
     return self;
 }
 B_IntegralD_u32 B_IntegralD_u32G_new() {
-    B_IntegralD_u32 $tmp = malloc(sizeof(struct B_IntegralD_u32));
+    B_IntegralD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u32), B_IntegralD_u32G_methods.$GCdescr);
     $tmp->$class = &B_IntegralD_u32G_methods;
     B_IntegralD_u32G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IntegralD_u32G_class B_IntegralD_u32G_methods;
+GC_word B_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u32)];
 B_NoneType B_MinusD_IntegralD_u32D___init__ (B_MinusD_IntegralD_u32 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -2365,7 +2455,7 @@ void B_MinusD_IntegralD_u32D___serialize__ (B_MinusD_IntegralD_u32 self, $Serial
 B_MinusD_IntegralD_u32 B_MinusD_IntegralD_u32D___deserialize__ (B_MinusD_IntegralD_u32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_IntegralD_u32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u32), B_MinusD_IntegralD_u32G_methods.$GCdescr);
             self->$class = &B_MinusD_IntegralD_u32G_methods;
             return self;
         }
@@ -2378,12 +2468,13 @@ B_MinusD_IntegralD_u32 B_MinusD_IntegralD_u32D___deserialize__ (B_MinusD_Integra
     return self;
 }
 B_MinusD_IntegralD_u32 B_MinusD_IntegralD_u32G_new(B_Integral G_1) {
-    B_MinusD_IntegralD_u32 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_u32));
+    B_MinusD_IntegralD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u32), B_MinusD_IntegralD_u32G_methods.$GCdescr);
     $tmp->$class = &B_MinusD_IntegralD_u32G_methods;
     B_MinusD_IntegralD_u32G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_IntegralD_u32G_class B_MinusD_IntegralD_u32G_methods;
+GC_word B_MinusD_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u32)];
 B_NoneType B_LogicalD_IntegralD_u32D___init__ (B_LogicalD_IntegralD_u32 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -2397,7 +2488,7 @@ void B_LogicalD_IntegralD_u32D___serialize__ (B_LogicalD_IntegralD_u32 self, $Se
 B_LogicalD_IntegralD_u32 B_LogicalD_IntegralD_u32D___deserialize__ (B_LogicalD_IntegralD_u32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_IntegralD_u32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u32), B_LogicalD_IntegralD_u32G_methods.$GCdescr);
             self->$class = &B_LogicalD_IntegralD_u32G_methods;
             return self;
         }
@@ -2407,12 +2498,13 @@ B_LogicalD_IntegralD_u32 B_LogicalD_IntegralD_u32D___deserialize__ (B_LogicalD_I
     return self;
 }
 B_LogicalD_IntegralD_u32 B_LogicalD_IntegralD_u32G_new(B_Integral G_1) {
-    B_LogicalD_IntegralD_u32 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_u32));
+    B_LogicalD_IntegralD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u32), B_LogicalD_IntegralD_u32G_methods.$GCdescr);
     $tmp->$class = &B_LogicalD_IntegralD_u32G_methods;
     B_LogicalD_IntegralD_u32G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_LogicalD_IntegralD_u32G_class B_LogicalD_IntegralD_u32G_methods;
+GC_word B_LogicalD_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u32)];
 B_NoneType B_DivD_u32D___init__ (B_DivD_u32 W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -2423,7 +2515,7 @@ void B_DivD_u32D___serialize__ (B_DivD_u32 self, $Serial$state state) {
 B_DivD_u32 B_DivD_u32D___deserialize__ (B_DivD_u32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_u32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u32), B_DivD_u32G_methods.$GCdescr);
             self->$class = &B_DivD_u32G_methods;
             return self;
         }
@@ -2432,12 +2524,13 @@ B_DivD_u32 B_DivD_u32D___deserialize__ (B_DivD_u32 self, $Serial$state state) {
     return self;
 }
 B_DivD_u32 B_DivD_u32G_new() {
-    B_DivD_u32 $tmp = malloc(sizeof(struct B_DivD_u32));
+    B_DivD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u32), B_DivD_u32G_methods.$GCdescr);
     $tmp->$class = &B_DivD_u32G_methods;
     B_DivD_u32G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_u32G_class B_DivD_u32G_methods;
+GC_word B_DivD_u32D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u32)];
 B_NoneType B_OrdD_u32D___init__ (B_OrdD_u32 W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -2449,7 +2542,7 @@ void B_OrdD_u32D___serialize__ (B_OrdD_u32 self, $Serial$state state) {
 B_OrdD_u32 B_OrdD_u32D___deserialize__ (B_OrdD_u32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_u32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u32), B_OrdD_u32G_methods.$GCdescr);
             self->$class = &B_OrdD_u32G_methods;
             return self;
         }
@@ -2458,12 +2551,13 @@ B_OrdD_u32 B_OrdD_u32D___deserialize__ (B_OrdD_u32 self, $Serial$state state) {
     return self;
 }
 B_OrdD_u32 B_OrdD_u32G_new() {
-    B_OrdD_u32 $tmp = malloc(sizeof(struct B_OrdD_u32));
+    B_OrdD_u32 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u32), B_OrdD_u32G_methods.$GCdescr);
     $tmp->$class = &B_OrdD_u32G_methods;
     B_OrdD_u32G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_u32G_class B_OrdD_u32G_methods;
+GC_word B_OrdD_u32D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u32)];
 B_NoneType B_HashableD_u32D___init__ (B_HashableD_u32 W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -2474,7 +2568,7 @@ void B_HashableD_u32D___serialize__ (B_HashableD_u32 self, $Serial$state state)
 B_HashableD_u32 B_HashableD_u32D___deserialize__ (B_HashableD_u32 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_u32));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_u32), B_HashableD_u32G_methods.$GCdescr);
             self->$class = &B_HashableD_u32G_methods;
             return self;
         }
@@ -2486,6 +2580,7 @@ B_HashableD_u32 B_HashableD_u32G_new() {   // manually added
     return $NEW(B_HashableD_u32);          //
 }                                          //
 struct B_HashableD_u32G_class B_HashableD_u32G_methods;
+GC_word B_HashableD_u32D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u32)];
 
 
 
@@ -2534,7 +2629,7 @@ void B_IntegralD_u16D___serialize__ (B_IntegralD_u16 self, $Serial$state state)
 B_IntegralD_u16 B_IntegralD_u16D___deserialize__ (B_IntegralD_u16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IntegralD_u16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u16), B_IntegralD_u16G_methods.$GCdescr);
             self->$class = &B_IntegralD_u16G_methods;
             return self;
         }
@@ -2545,12 +2640,13 @@ B_IntegralD_u16 B_IntegralD_u16D___deserialize__ (B_IntegralD_u16 self, $Serial$
     return self;
 }
 B_IntegralD_u16 B_IntegralD_u16G_new() {
-    B_IntegralD_u16 $tmp = malloc(sizeof(struct B_IntegralD_u16));
+    B_IntegralD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IntegralD_u16), B_IntegralD_u16G_methods.$GCdescr);
     $tmp->$class = &B_IntegralD_u16G_methods;
     B_IntegralD_u16G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IntegralD_u16G_class B_IntegralD_u16G_methods;
+GC_word B_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u16)];
 B_NoneType B_MinusD_IntegralD_u16D___init__ (B_MinusD_IntegralD_u16 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_MinusD_Integral, B_Integral))B_MinusD_IntegralG_methods.__init__)(((B_MinusD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -2565,7 +2661,7 @@ void B_MinusD_IntegralD_u16D___serialize__ (B_MinusD_IntegralD_u16 self, $Serial
 B_MinusD_IntegralD_u16 B_MinusD_IntegralD_u16D___deserialize__ (B_MinusD_IntegralD_u16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_IntegralD_u16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u16), B_MinusD_IntegralD_u16G_methods.$GCdescr);
             self->$class = &B_MinusD_IntegralD_u16G_methods;
             return self;
         }
@@ -2578,12 +2674,13 @@ B_MinusD_IntegralD_u16 B_MinusD_IntegralD_u16D___deserialize__ (B_MinusD_Integra
     return self;
 }
 B_MinusD_IntegralD_u16 B_MinusD_IntegralD_u16G_new(B_Integral G_1) {
-    B_MinusD_IntegralD_u16 $tmp = malloc(sizeof(struct B_MinusD_IntegralD_u16));
+    B_MinusD_IntegralD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_IntegralD_u16), B_MinusD_IntegralD_u16G_methods.$GCdescr);
     $tmp->$class = &B_MinusD_IntegralD_u16G_methods;
     B_MinusD_IntegralD_u16G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_IntegralD_u16G_class B_MinusD_IntegralD_u16G_methods;
+GC_word B_MinusD_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u16)];
 B_NoneType B_LogicalD_IntegralD_u16D___init__ (B_LogicalD_IntegralD_u16 W_self, B_Integral W_Integral) {
     ((B_NoneType (*) (B_LogicalD_Integral, B_Integral))B_LogicalD_IntegralG_methods.__init__)(((B_LogicalD_Integral)W_self), ((B_Integral)W_Integral));
     return B_None;
@@ -2597,7 +2694,7 @@ void B_LogicalD_IntegralD_u16D___serialize__ (B_LogicalD_IntegralD_u16 self, $Se
 B_LogicalD_IntegralD_u16 B_LogicalD_IntegralD_u16D___deserialize__ (B_LogicalD_IntegralD_u16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_IntegralD_u16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u16), B_LogicalD_IntegralD_u16G_methods.$GCdescr);
             self->$class = &B_LogicalD_IntegralD_u16G_methods;
             return self;
         }
@@ -2607,12 +2704,13 @@ B_LogicalD_IntegralD_u16 B_LogicalD_IntegralD_u16D___deserialize__ (B_LogicalD_I
     return self;
 }
 B_LogicalD_IntegralD_u16 B_LogicalD_IntegralD_u16G_new(B_Integral G_1) {
-    B_LogicalD_IntegralD_u16 $tmp = malloc(sizeof(struct B_LogicalD_IntegralD_u16));
+    B_LogicalD_IntegralD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_IntegralD_u16), B_LogicalD_IntegralD_u16G_methods.$GCdescr);
     $tmp->$class = &B_LogicalD_IntegralD_u16G_methods;
     B_LogicalD_IntegralD_u16G_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_LogicalD_IntegralD_u16G_class B_LogicalD_IntegralD_u16G_methods;
+GC_word B_LogicalD_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u16)];
 B_NoneType B_DivD_u16D___init__ (B_DivD_u16 W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -2623,7 +2721,7 @@ void B_DivD_u16D___serialize__ (B_DivD_u16 self, $Serial$state state) {
 B_DivD_u16 B_DivD_u16D___deserialize__ (B_DivD_u16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_u16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u16), B_DivD_u16G_methods.$GCdescr);
             self->$class = &B_DivD_u16G_methods;
             return self;
         }
@@ -2632,12 +2730,13 @@ B_DivD_u16 B_DivD_u16D___deserialize__ (B_DivD_u16 self, $Serial$state state) {
     return self;
 }
 B_DivD_u16 B_DivD_u16G_new() {
-    B_DivD_u16 $tmp = malloc(sizeof(struct B_DivD_u16));
+    B_DivD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_u16), B_DivD_u16G_methods.$GCdescr);
     $tmp->$class = &B_DivD_u16G_methods;
     B_DivD_u16G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_u16G_class B_DivD_u16G_methods;
+GC_word B_DivD_u16D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u16)];
 B_NoneType B_OrdD_u16D___init__ (B_OrdD_u16 W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -2649,7 +2748,7 @@ void B_OrdD_u16D___serialize__ (B_OrdD_u16 self, $Serial$state state) {
 B_OrdD_u16 B_OrdD_u16D___deserialize__ (B_OrdD_u16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_u16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u16), B_OrdD_u16G_methods.$GCdescr);
             self->$class = &B_OrdD_u16G_methods;
             return self;
         }
@@ -2658,12 +2757,13 @@ B_OrdD_u16 B_OrdD_u16D___deserialize__ (B_OrdD_u16 self, $Serial$state state) {
     return self;
 }
 B_OrdD_u16 B_OrdD_u16G_new() {
-    B_OrdD_u16 $tmp = malloc(sizeof(struct B_OrdD_u16));
+    B_OrdD_u16 $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_u16), B_OrdD_u16G_methods.$GCdescr);
     $tmp->$class = &B_OrdD_u16G_methods;
     B_OrdD_u16G_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_u16G_class B_OrdD_u16G_methods;
+GC_word B_OrdD_u16D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u16)];
 B_NoneType B_HashableD_u16D___init__ (B_HashableD_u16 W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -2674,7 +2774,7 @@ void B_HashableD_u16D___serialize__ (B_HashableD_u16 self, $Serial$state state)
 B_HashableD_u16 B_HashableD_u16D___deserialize__ (B_HashableD_u16 self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_u16));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_u16), B_HashableD_u16G_methods.$GCdescr);
             self->$class = &B_HashableD_u16G_methods;
             return self;
         }
@@ -2686,6 +2786,7 @@ B_HashableD_u16 B_HashableD_u16G_new() {   // manually added
     return $NEW(B_HashableD_u16);          //
 }                                          //
 struct B_HashableD_u16G_class B_HashableD_u16G_methods;
+GC_word B_HashableD_u16D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u16)];
 
 
 
@@ -2724,7 +2825,7 @@ void B_RealFloatD_floatD___serialize__ (B_RealFloatD_float self, $Serial$state s
 B_RealFloatD_float B_RealFloatD_floatD___deserialize__ (B_RealFloatD_float self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_RealFloatD_float));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RealFloatD_float), B_RealFloatD_floatG_methods.$GCdescr);
             self->$class = &B_RealFloatD_floatG_methods;
             return self;
         }
@@ -2734,12 +2835,13 @@ B_RealFloatD_float B_RealFloatD_floatD___deserialize__ (B_RealFloatD_float self,
     return self;
 }
 B_RealFloatD_float B_RealFloatD_floatG_new() {
-    B_RealFloatD_float $tmp = malloc(sizeof(struct B_RealFloatD_float));
+    B_RealFloatD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_RealFloatD_float), B_RealFloatD_floatG_methods.$GCdescr);
     $tmp->$class = &B_RealFloatD_floatG_methods;
     B_RealFloatD_floatG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_RealFloatD_floatG_class B_RealFloatD_floatG_methods;
+GC_word B_RealFloatD_floatD_gcbm[GC_BITMAP_SIZE(struct B_RealFloatD_float)];
 B_NoneType B_MinusD_RealFloatD_floatD___init__ (B_MinusD_RealFloatD_float W_self, B_RealFloat W_RealFloat) {
     ((B_NoneType (*) (B_MinusD_RealFloat, B_RealFloat))B_MinusD_RealFloatG_methods.__init__)(((B_MinusD_RealFloat)W_self), ((B_RealFloat)W_RealFloat));
     return B_None;
@@ -2753,7 +2855,7 @@ void B_MinusD_RealFloatD_floatD___serialize__ (B_MinusD_RealFloatD_float self, $
 B_MinusD_RealFloatD_float B_MinusD_RealFloatD_floatD___deserialize__ (B_MinusD_RealFloatD_float self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_RealFloatD_float));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_RealFloatD_float), B_MinusD_RealFloatD_floatG_methods.$GCdescr);
             self->$class = &B_MinusD_RealFloatD_floatG_methods;
             return self;
         }
@@ -2765,12 +2867,13 @@ B_MinusD_RealFloatD_float B_MinusD_RealFloatD_floatD___deserialize__ (B_MinusD_R
     return self;
 }
 B_MinusD_RealFloatD_float B_MinusD_RealFloatD_floatG_new(B_RealFloat G_1) {
-    B_MinusD_RealFloatD_float $tmp = malloc(sizeof(struct B_MinusD_RealFloatD_float));
+    B_MinusD_RealFloatD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_RealFloatD_float), B_MinusD_RealFloatD_floatG_methods.$GCdescr);
     $tmp->$class = &B_MinusD_RealFloatD_floatG_methods;
     B_MinusD_RealFloatD_floatG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_RealFloatD_floatG_class B_MinusD_RealFloatD_floatG_methods;
+GC_word B_MinusD_RealFloatD_floatD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_RealFloatD_float)];
 B_NoneType B_DivD_floatD___init__ (B_DivD_float W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -2781,7 +2884,7 @@ void B_DivD_floatD___serialize__ (B_DivD_float self, $Serial$state state) {
 B_DivD_float B_DivD_floatD___deserialize__ (B_DivD_float self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_float));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_float), B_DivD_floatG_methods.$GCdescr);
             self->$class = &B_DivD_floatG_methods;
             return self;
         }
@@ -2790,12 +2893,13 @@ B_DivD_float B_DivD_floatD___deserialize__ (B_DivD_float self, $Serial$state sta
     return self;
 }
 B_DivD_float B_DivD_floatG_new() {
-    B_DivD_float $tmp = malloc(sizeof(struct B_DivD_float));
+    B_DivD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_float), B_DivD_floatG_methods.$GCdescr);
     $tmp->$class = &B_DivD_floatG_methods;
     B_DivD_floatG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_floatG_class B_DivD_floatG_methods;
+GC_word B_DivD_floatD_gcbm[GC_BITMAP_SIZE(struct B_DivD_float)];
 B_NoneType B_OrdD_floatD___init__ (B_OrdD_float W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -2807,7 +2911,7 @@ void B_OrdD_floatD___serialize__ (B_OrdD_float self, $Serial$state state) {
 B_OrdD_float B_OrdD_floatD___deserialize__ (B_OrdD_float self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_float));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_float), B_OrdD_floatG_methods.$GCdescr);
             self->$class = &B_OrdD_floatG_methods;
             return self;
         }
@@ -2816,12 +2920,13 @@ B_OrdD_float B_OrdD_floatD___deserialize__ (B_OrdD_float self, $Serial$state sta
     return self;
 }
 B_OrdD_float B_OrdD_floatG_new() {
-    B_OrdD_float $tmp = malloc(sizeof(struct B_OrdD_float));
+    B_OrdD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_float), B_OrdD_floatG_methods.$GCdescr);
     $tmp->$class = &B_OrdD_floatG_methods;
     B_OrdD_floatG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_floatG_class B_OrdD_floatG_methods;
+GC_word B_OrdD_floatD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_float)];
 B_NoneType B_HashableD_floatD___init__ (B_HashableD_float W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -2832,7 +2937,7 @@ void B_HashableD_floatD___serialize__ (B_HashableD_float self, $Serial$state sta
 B_HashableD_float B_HashableD_floatD___deserialize__ (B_HashableD_float self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_float));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_float), B_HashableD_floatG_methods.$GCdescr);
             self->$class = &B_HashableD_floatG_methods;
             return self;
         }
@@ -2841,6 +2946,7 @@ B_HashableD_float B_HashableD_floatD___deserialize__ (B_HashableD_float self, $S
     return self;
 }
 struct B_HashableD_floatG_class B_HashableD_floatG_methods;
+GC_word B_HashableD_floatD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_float)];
 B_NoneType B_NumberD_complexD___init__ (B_NumberD_complex W_self) {
     ((B_NoneType (*) (B_Number, B_Minus))B_NumberG_methods.__init__)(((B_Number)W_self), ((B_Minus)B_MinusD_NumberD_complexG_new(((B_Number)W_self))));
     return B_None;
@@ -2862,7 +2968,7 @@ void B_NumberD_complexD___serialize__ (B_NumberD_complex self, $Serial$state sta
 B_NumberD_complex B_NumberD_complexD___deserialize__ (B_NumberD_complex self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_NumberD_complex));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_NumberD_complex), B_NumberD_complexG_methods.$GCdescr);
             self->$class = &B_NumberD_complexG_methods;
             return self;
         }
@@ -2872,12 +2978,13 @@ B_NumberD_complex B_NumberD_complexD___deserialize__ (B_NumberD_complex self, $S
     return self;
 }
 B_NumberD_complex B_NumberD_complexG_new() {
-    B_NumberD_complex $tmp = malloc(sizeof(struct B_NumberD_complex));
+    B_NumberD_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_NumberD_complex), B_NumberD_complexG_methods.$GCdescr);
     $tmp->$class = &B_NumberD_complexG_methods;
     B_NumberD_complexG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_NumberD_complexG_class B_NumberD_complexG_methods;
+GC_word B_NumberD_complexD_gcbm[GC_BITMAP_SIZE(struct B_NumberD_complex)];
 B_NoneType B_MinusD_NumberD_complexD___init__ (B_MinusD_NumberD_complex W_self, B_Number W_Number) {
     ((B_NoneType (*) (B_MinusD_Number, B_Number))B_MinusD_NumberG_methods.__init__)(((B_MinusD_Number)W_self), ((B_Number)W_Number));
     return B_None;
@@ -2889,7 +2996,7 @@ void B_MinusD_NumberD_complexD___serialize__ (B_MinusD_NumberD_complex self, $Se
 B_MinusD_NumberD_complex B_MinusD_NumberD_complexD___deserialize__ (B_MinusD_NumberD_complex self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_NumberD_complex));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_NumberD_complex), B_MinusD_NumberD_complexG_methods.$GCdescr);
             self->$class = &B_MinusD_NumberD_complexG_methods;
             return self;
         }
@@ -2899,12 +3006,13 @@ B_MinusD_NumberD_complex B_MinusD_NumberD_complexD___deserialize__ (B_MinusD_Num
     return self;
 }
 B_MinusD_NumberD_complex B_MinusD_NumberD_complexG_new(B_Number G_1) {
-    B_MinusD_NumberD_complex $tmp = malloc(sizeof(struct B_MinusD_NumberD_complex));
+    B_MinusD_NumberD_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_NumberD_complex), B_MinusD_NumberD_complexG_methods.$GCdescr);
     $tmp->$class = &B_MinusD_NumberD_complexG_methods;
     B_MinusD_NumberD_complexG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MinusD_NumberD_complexG_class B_MinusD_NumberD_complexG_methods;
+GC_word B_MinusD_NumberD_complexD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_NumberD_complex)];
 B_NoneType B_DivD_complexD___init__ (B_DivD_complex W_self) {
     ((B_NoneType (*) (B_Div))B_DivG_methods.__init__)(((B_Div)W_self));
     return B_None;
@@ -2915,7 +3023,7 @@ void B_DivD_complexD___serialize__ (B_DivD_complex self, $Serial$state state) {
 B_DivD_complex B_DivD_complexD___deserialize__ (B_DivD_complex self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_DivD_complex));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_complex), B_DivD_complexG_methods.$GCdescr);
             self->$class = &B_DivD_complexG_methods;
             return self;
         }
@@ -2924,12 +3032,13 @@ B_DivD_complex B_DivD_complexD___deserialize__ (B_DivD_complex self, $Serial$sta
     return self;
 }
 B_DivD_complex B_DivD_complexG_new() {
-    B_DivD_complex $tmp = malloc(sizeof(struct B_DivD_complex));
+    B_DivD_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_DivD_complex), B_DivD_complexG_methods.$GCdescr);
     $tmp->$class = &B_DivD_complexG_methods;
     B_DivD_complexG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_DivD_complexG_class B_DivD_complexG_methods;
+GC_word B_DivD_complexD_gcbm[GC_BITMAP_SIZE(struct B_DivD_complex)];
 B_NoneType B_EqD_complexD___init__ (B_EqD_complex W_self) {
     ((B_NoneType (*) (B_Eq))B_EqG_methods.__init__)(((B_Eq)W_self));
     return B_None;
@@ -2940,7 +3049,7 @@ void B_EqD_complexD___serialize__ (B_EqD_complex self, $Serial$state state) {
 B_EqD_complex B_EqD_complexD___deserialize__ (B_EqD_complex self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_EqD_complex));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_EqD_complex), B_EqD_complexG_methods.$GCdescr);
             self->$class = &B_EqD_complexG_methods;
             return self;
         }
@@ -2949,12 +3058,13 @@ B_EqD_complex B_EqD_complexD___deserialize__ (B_EqD_complex self, $Serial$state
     return self;
 }
 B_EqD_complex B_EqD_complexG_new() {
-    B_EqD_complex $tmp = malloc(sizeof(struct B_EqD_complex));
+    B_EqD_complex $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_EqD_complex), B_EqD_complexG_methods.$GCdescr);
     $tmp->$class = &B_EqD_complexG_methods;
     B_EqD_complexG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_EqD_complexG_class B_EqD_complexG_methods;
+GC_word B_EqD_complexD_gcbm[GC_BITMAP_SIZE(struct B_EqD_complex)];
 B_NoneType B_HashableD_complexD___init__ (B_HashableD_complex W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -2965,7 +3075,7 @@ void B_HashableD_complexD___serialize__ (B_HashableD_complex self, $Serial$state
 B_HashableD_complex B_HashableD_complexD___deserialize__ (B_HashableD_complex self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_complex));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_complex), B_HashableD_complexG_methods.$GCdescr);
             self->$class = &B_HashableD_complexG_methods;
             return self;
         }
@@ -2974,6 +3084,7 @@ B_HashableD_complex B_HashableD_complexD___deserialize__ (B_HashableD_complex se
     return self;
 }
 struct B_HashableD_complexG_class B_HashableD_complexG_methods;
+GC_word B_HashableD_complexD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_complex)];
 B_NoneType B_IndexedD___init__ (B_Indexed W_self, B_Eq W_EqD_A) {
     W_self->W_EqD_AD_Indexed = W_EqD_A;
     return B_None;
@@ -2984,7 +3095,7 @@ void B_IndexedD___serialize__ (B_Indexed self, $Serial$state state) {
 B_Indexed B_IndexedD___deserialize__ (B_Indexed self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Indexed));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Indexed), B_IndexedG_methods.$GCdescr);
             self->$class = &B_IndexedG_methods;
             return self;
         }
@@ -2994,6 +3105,7 @@ B_Indexed B_IndexedD___deserialize__ (B_Indexed self, $Serial$state state) {
     return self;
 }
 struct B_IndexedG_class B_IndexedG_methods;
+GC_word B_IndexedD_gcbm[GC_BITMAP_SIZE(struct B_Indexed)];
 B_NoneType B_SliceableD___init__ (B_Sliceable W_self) {
     B_Eq W_333 = ((B_Eq)B_OrdD_intG_new());
     ((B_NoneType (*) (B_Indexed, B_Eq))B_IndexedG_methods.__init__)(((B_Indexed)W_self), W_333);
@@ -3005,7 +3117,7 @@ void B_SliceableD___serialize__ (B_Sliceable self, $Serial$state state) {
 B_Sliceable B_SliceableD___deserialize__ (B_Sliceable self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Sliceable));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Sliceable), B_SliceableG_methods.$GCdescr);
             self->$class = &B_SliceableG_methods;
             return self;
         }
@@ -3015,6 +3127,7 @@ B_Sliceable B_SliceableD___deserialize__ (B_Sliceable self, $Serial$state state)
     return self;
 }
 struct B_SliceableG_class B_SliceableG_methods;
+GC_word B_SliceableD_gcbm[GC_BITMAP_SIZE(struct B_Sliceable)];
 B_NoneType B_CollectionD___init__ (B_Collection W_self) {
     ((B_NoneType (*) (B_Iterable))B_IterableG_methods.__init__)(((B_Iterable)W_self));
     return B_None;
@@ -3024,7 +3137,7 @@ void B_CollectionD___serialize__ (B_Collection self, $Serial$state state) {
 B_Collection B_CollectionD___deserialize__ (B_Collection self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Collection));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Collection), B_CollectionG_methods.$GCdescr);
             self->$class = &B_CollectionG_methods;
             return self;
         }
@@ -3033,6 +3146,7 @@ B_Collection B_CollectionD___deserialize__ (B_Collection self, $Serial$state sta
     return self;
 }
 struct B_CollectionG_class B_CollectionG_methods;
+GC_word B_CollectionD_gcbm[GC_BITMAP_SIZE(struct B_Collection)];
 B_NoneType B_ContainerD___init__ (B_Container W_self, B_Eq W_EqD_A) {
     ((B_NoneType (*) (B_Collection))B_CollectionG_methods.__init__)(((B_Collection)W_self));
     W_self->W_EqD_AD_Container = W_EqD_A;
@@ -3044,7 +3158,7 @@ void B_ContainerD___serialize__ (B_Container self, $Serial$state state) {
 B_Container B_ContainerD___deserialize__ (B_Container self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Container));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Container), B_ContainerG_methods.$GCdescr);
             self->$class = &B_ContainerG_methods;
             return self;
         }
@@ -3054,6 +3168,7 @@ B_Container B_ContainerD___deserialize__ (B_Container self, $Serial$state state)
     return self;
 }
 struct B_ContainerG_class B_ContainerG_methods;
+GC_word B_ContainerD_gcbm[GC_BITMAP_SIZE(struct B_Container)];
 B_NoneType B_SequenceD___init__ (B_Sequence W_self, B_Collection W_Collection, B_Times W_Times) {
     ((B_NoneType (*) (B_Sliceable))B_SliceableG_methods.__init__)(((B_Sliceable)W_self));
     W_self->W_Collection = W_Collection;
@@ -3068,7 +3183,7 @@ void B_SequenceD___serialize__ (B_Sequence self, $Serial$state state) {
 B_Sequence B_SequenceD___deserialize__ (B_Sequence self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Sequence));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Sequence), B_SequenceG_methods.$GCdescr);
             self->$class = &B_SequenceG_methods;
             return self;
         }
@@ -3080,6 +3195,7 @@ B_Sequence B_SequenceD___deserialize__ (B_Sequence self, $Serial$state state) {
     return self;
 }
 struct B_SequenceG_class B_SequenceG_methods;
+GC_word B_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_Sequence)];
 B_NoneType B_CollectionD_SequenceD___init__ (B_CollectionD_Sequence W_self, B_Sequence W_Sequence) {
     ((B_NoneType (*) (B_Collection))B_CollectionG_methods.__init__)(((B_Collection)W_self));
     W_self->W_Sequence = W_Sequence;
@@ -3091,7 +3207,7 @@ void B_CollectionD_SequenceD___serialize__ (B_CollectionD_Sequence self, $Serial
 B_CollectionD_Sequence B_CollectionD_SequenceD___deserialize__ (B_CollectionD_Sequence self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_CollectionD_Sequence));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_Sequence), B_CollectionD_SequenceG_methods.$GCdescr);
             self->$class = &B_CollectionD_SequenceG_methods;
             return self;
         }
@@ -3101,6 +3217,7 @@ B_CollectionD_Sequence B_CollectionD_SequenceD___deserialize__ (B_CollectionD_Se
     return self;
 }
 struct B_CollectionD_SequenceG_class B_CollectionD_SequenceG_methods;
+GC_word B_CollectionD_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_Sequence)];
 B_NoneType B_TimesD_SequenceD___init__ (B_TimesD_Sequence W_self, B_Sequence W_Sequence) {
     ((B_NoneType (*) (B_Times))B_TimesG_methods.__init__)(((B_Times)W_self));
     W_self->W_Sequence = W_Sequence;
@@ -3112,7 +3229,7 @@ void B_TimesD_SequenceD___serialize__ (B_TimesD_Sequence self, $Serial$state sta
 B_TimesD_Sequence B_TimesD_SequenceD___deserialize__ (B_TimesD_Sequence self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_TimesD_Sequence));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_Sequence), B_TimesD_SequenceG_methods.$GCdescr);
             self->$class = &B_TimesD_SequenceG_methods;
             return self;
         }
@@ -3122,6 +3239,7 @@ B_TimesD_Sequence B_TimesD_SequenceD___deserialize__ (B_TimesD_Sequence self, $S
     return self;
 }
 struct B_TimesD_SequenceG_class B_TimesD_SequenceG_methods;
+GC_word B_TimesD_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_Sequence)];
 B_NoneType B_MappingD___init__ (B_Mapping W_self, B_Eq W_EqD_A, B_Indexed W_Indexed) {
     ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_EqD_A);
     W_self->W_EqD_AD_Mapping = W_EqD_A;
@@ -3136,7 +3254,7 @@ void B_MappingD___serialize__ (B_Mapping self, $Serial$state state) {
 B_Mapping B_MappingD___deserialize__ (B_Mapping self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Mapping));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Mapping), B_MappingG_methods.$GCdescr);
             self->$class = &B_MappingG_methods;
             return self;
         }
@@ -3148,6 +3266,7 @@ B_Mapping B_MappingD___deserialize__ (B_Mapping self, $Serial$state state) {
     return self;
 }
 struct B_MappingG_class B_MappingG_methods;
+GC_word B_MappingD_gcbm[GC_BITMAP_SIZE(struct B_Mapping)];
 B_NoneType B_IndexedD_MappingD___init__ (B_IndexedD_Mapping W_self, B_Eq W_EqD_A, B_Mapping W_Mapping) {
     ((B_NoneType (*) (B_Indexed, B_Eq))B_IndexedG_methods.__init__)(((B_Indexed)W_self), W_EqD_A);
     W_self->W_EqD_AD_Mapping = W_EqD_A;
@@ -3162,7 +3281,7 @@ void B_IndexedD_MappingD___serialize__ (B_IndexedD_Mapping self, $Serial$state s
 B_IndexedD_Mapping B_IndexedD_MappingD___deserialize__ (B_IndexedD_Mapping self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IndexedD_Mapping));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexedD_Mapping), B_IndexedD_MappingG_methods.$GCdescr);
             self->$class = &B_IndexedD_MappingG_methods;
             return self;
         }
@@ -3174,6 +3293,7 @@ B_IndexedD_Mapping B_IndexedD_MappingD___deserialize__ (B_IndexedD_Mapping self,
     return self;
 }
 struct B_IndexedD_MappingG_class B_IndexedD_MappingG_methods;
+GC_word B_IndexedD_MappingD_gcbm[GC_BITMAP_SIZE(struct B_IndexedD_Mapping)];
 B_NoneType B_SetD___init__ (B_Set W_self, B_Eq W_EqD_A, B_Ord W_Ord, B_Logical W_Logical, B_Minus W_Minus) {
     ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_EqD_A);
     W_self->W_EqD_AD_Set = W_EqD_A;
@@ -3192,7 +3312,7 @@ void B_SetD___serialize__ (B_Set self, $Serial$state state) {
 B_Set B_SetD___deserialize__ (B_Set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Set), B_SetG_methods.$GCdescr);
             self->$class = &B_SetG_methods;
             return self;
         }
@@ -3206,6 +3326,7 @@ B_Set B_SetD___deserialize__ (B_Set self, $Serial$state state) {
     return self;
 }
 struct B_SetG_class B_SetG_methods;
+GC_word B_SetD_gcbm[GC_BITMAP_SIZE(struct B_Set)];
 B_NoneType B_OrdD_SetD___init__ (B_OrdD_Set W_self, B_Eq W_EqD_A, B_Set W_Set) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     W_self->W_EqD_AD_Set = W_EqD_A;
@@ -3219,7 +3340,7 @@ void B_OrdD_SetD___serialize__ (B_OrdD_Set self, $Serial$state state) {
 B_OrdD_Set B_OrdD_SetD___deserialize__ (B_OrdD_Set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_Set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_Set), B_OrdD_SetG_methods.$GCdescr);
             self->$class = &B_OrdD_SetG_methods;
             return self;
         }
@@ -3230,6 +3351,7 @@ B_OrdD_Set B_OrdD_SetD___deserialize__ (B_OrdD_Set self, $Serial$state state) {
     return self;
 }
 struct B_OrdD_SetG_class B_OrdD_SetG_methods;
+GC_word B_OrdD_SetD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_Set)];
 B_NoneType B_LogicalD_SetD___init__ (B_LogicalD_Set W_self, B_Eq W_EqD_A, B_Set W_Set) {
     ((B_NoneType (*) (B_Logical))B_LogicalG_methods.__init__)(((B_Logical)W_self));
     W_self->W_EqD_AD_Set = W_EqD_A;
@@ -3243,7 +3365,7 @@ void B_LogicalD_SetD___serialize__ (B_LogicalD_Set self, $Serial$state state) {
 B_LogicalD_Set B_LogicalD_SetD___deserialize__ (B_LogicalD_Set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_Set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_Set), B_LogicalD_SetG_methods.$GCdescr);
             self->$class = &B_LogicalD_SetG_methods;
             return self;
         }
@@ -3254,6 +3376,7 @@ B_LogicalD_Set B_LogicalD_SetD___deserialize__ (B_LogicalD_Set self, $Serial$sta
     return self;
 }
 struct B_LogicalD_SetG_class B_LogicalD_SetG_methods;
+GC_word B_LogicalD_SetD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_Set)];
 B_NoneType B_MinusD_SetD___init__ (B_MinusD_Set W_self, B_Eq W_EqD_A, B_Set W_Set) {
     ((B_NoneType (*) (B_Minus))B_MinusG_methods.__init__)(((B_Minus)W_self));
     W_self->W_EqD_AD_Set = W_EqD_A;
@@ -3267,7 +3390,7 @@ void B_MinusD_SetD___serialize__ (B_MinusD_Set self, $Serial$state state) {
 B_MinusD_Set B_MinusD_SetD___deserialize__ (B_MinusD_Set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_Set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_Set), B_MinusD_SetG_methods.$GCdescr);
             self->$class = &B_MinusD_SetG_methods;
             return self;
         }
@@ -3278,6 +3401,7 @@ B_MinusD_Set B_MinusD_SetD___deserialize__ (B_MinusD_Set self, $Serial$state sta
     return self;
 }
 struct B_MinusD_SetG_class B_MinusD_SetG_methods;
+GC_word B_MinusD_SetD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Set)];
 B_NoneType B_SequenceD_listD___init__ (B_SequenceD_list W_self) {
     ((B_NoneType (*) (B_Sequence, B_Collection, B_Times))B_SequenceG_methods.__init__)(((B_Sequence)W_self), ((B_Collection)B_CollectionD_SequenceD_listG_new(((B_Sequence)W_self))), ((B_Times)B_TimesD_SequenceD_listG_new(((B_Sequence)W_self))));
     return B_None;
@@ -3300,7 +3424,7 @@ void B_SequenceD_listD___serialize__ (B_SequenceD_list self, $Serial$state state
 B_SequenceD_list B_SequenceD_listD___deserialize__ (B_SequenceD_list self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_SequenceD_list));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SequenceD_list), B_SequenceD_listG_methods.$GCdescr);
             self->$class = &B_SequenceD_listG_methods;
             return self;
         }
@@ -3312,12 +3436,13 @@ B_SequenceD_list B_SequenceD_listD___deserialize__ (B_SequenceD_list self, $Seri
     return self;
 }
 B_SequenceD_list B_SequenceD_listG_new() {
-    B_SequenceD_list $tmp = malloc(sizeof(struct B_SequenceD_list));
+    B_SequenceD_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SequenceD_list), B_SequenceD_listG_methods.$GCdescr);
     $tmp->$class = &B_SequenceD_listG_methods;
     B_SequenceD_listG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_SequenceD_listG_class B_SequenceD_listG_methods;
+GC_word B_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_SequenceD_list)];
 B_NoneType B_CollectionD_SequenceD_listD___init__ (B_CollectionD_SequenceD_list W_self, B_Sequence W_Sequence) {
     ((B_NoneType (*) (B_CollectionD_Sequence, B_Sequence))B_CollectionD_SequenceG_methods.__init__)(((B_CollectionD_Sequence)W_self), ((B_Sequence)W_Sequence));
     return B_None;
@@ -3331,7 +3456,7 @@ void B_CollectionD_SequenceD_listD___serialize__ (B_CollectionD_SequenceD_list s
 B_CollectionD_SequenceD_list B_CollectionD_SequenceD_listD___deserialize__ (B_CollectionD_SequenceD_list self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_CollectionD_SequenceD_list));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_SequenceD_list), B_CollectionD_SequenceD_listG_methods.$GCdescr);
             self->$class = &B_CollectionD_SequenceD_listG_methods;
             return self;
         }
@@ -3341,12 +3466,13 @@ B_CollectionD_SequenceD_list B_CollectionD_SequenceD_listD___deserialize__ (B_Co
     return self;
 }
 B_CollectionD_SequenceD_list B_CollectionD_SequenceD_listG_new(B_Sequence G_1) {
-    B_CollectionD_SequenceD_list $tmp = malloc(sizeof(struct B_CollectionD_SequenceD_list));
+    B_CollectionD_SequenceD_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_SequenceD_list), B_CollectionD_SequenceD_listG_methods.$GCdescr);
     $tmp->$class = &B_CollectionD_SequenceD_listG_methods;
     B_CollectionD_SequenceD_listG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_CollectionD_SequenceD_listG_class B_CollectionD_SequenceD_listG_methods;
+GC_word B_CollectionD_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_SequenceD_list)];
 B_NoneType B_TimesD_SequenceD_listD___init__ (B_TimesD_SequenceD_list W_self, B_Sequence W_Sequence) {
     ((B_NoneType (*) (B_TimesD_Sequence, B_Sequence))B_TimesD_SequenceG_methods.__init__)(((B_TimesD_Sequence)W_self), ((B_Sequence)W_Sequence));
     return B_None;
@@ -3359,7 +3485,7 @@ void B_TimesD_SequenceD_listD___serialize__ (B_TimesD_SequenceD_list self, $Seri
 B_TimesD_SequenceD_list B_TimesD_SequenceD_listD___deserialize__ (B_TimesD_SequenceD_list self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_TimesD_SequenceD_list));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_SequenceD_list), B_TimesD_SequenceD_listG_methods.$GCdescr);
             self->$class = &B_TimesD_SequenceD_listG_methods;
             return self;
         }
@@ -3369,12 +3495,13 @@ B_TimesD_SequenceD_list B_TimesD_SequenceD_listD___deserialize__ (B_TimesD_Seque
     return self;
 }
 B_TimesD_SequenceD_list B_TimesD_SequenceD_listG_new(B_Sequence G_1) {
-    B_TimesD_SequenceD_list $tmp = malloc(sizeof(struct B_TimesD_SequenceD_list));
+    B_TimesD_SequenceD_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_SequenceD_list), B_TimesD_SequenceD_listG_methods.$GCdescr);
     $tmp->$class = &B_TimesD_SequenceD_listG_methods;
     B_TimesD_SequenceD_listG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_TimesD_SequenceD_listG_class B_TimesD_SequenceD_listG_methods;
+GC_word B_TimesD_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_SequenceD_list)];
 B_NoneType B_ContainerD_listD___init__ (B_ContainerD_list W_self, B_Eq W_EqD_A) {
     ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_EqD_A);
     W_self->W_EqD_AD_ContainerD_list = W_EqD_A;
@@ -3389,7 +3516,7 @@ void B_ContainerD_listD___serialize__ (B_ContainerD_list self, $Serial$state sta
 B_ContainerD_list B_ContainerD_listD___deserialize__ (B_ContainerD_list self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_ContainerD_list));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_list), B_ContainerD_listG_methods.$GCdescr);
             self->$class = &B_ContainerD_listG_methods;
             return self;
         }
@@ -3403,6 +3530,7 @@ B_ContainerD_list B_ContainerD_listG_new(B_Eq w) { // Why is this not generated
     return $NEW(B_ContainerD_list,w);              //
 }                                                  //
 struct B_ContainerD_listG_class B_ContainerD_listG_methods;
+GC_word B_ContainerD_listD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_list)];
 B_NoneType B_OrdD_listD___init__ (B_OrdD_list W_self, B_Ord W_OrdD_A) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     W_self->W_OrdD_AD_OrdD_list = W_OrdD_A;
@@ -3416,7 +3544,7 @@ void B_OrdD_listD___serialize__ (B_OrdD_list self, $Serial$state state) {
 B_OrdD_list B_OrdD_listD___deserialize__ (B_OrdD_list self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_list));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_list), B_OrdD_listG_methods.$GCdescr);
             self->$class = &B_OrdD_listG_methods;
             return self;
         }
@@ -3426,12 +3554,13 @@ B_OrdD_list B_OrdD_listD___deserialize__ (B_OrdD_list self, $Serial$state state)
     return self;
 }
 B_OrdD_list B_OrdD_listG_new(B_Ord G_1) {
-    B_OrdD_list $tmp = malloc(sizeof(struct B_OrdD_list));
+    B_OrdD_list $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_list), B_OrdD_listG_methods.$GCdescr);
     $tmp->$class = &B_OrdD_listG_methods;
     B_OrdD_listG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_OrdD_listG_class B_OrdD_listG_methods;
+GC_word B_OrdD_listD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_list)];
 B_NoneType B_MappingD_dictD___init__ (B_MappingD_dict W_self, B_Hashable W_HashableD_A) {
     ((B_NoneType (*) (B_Mapping, B_Eq, B_Indexed))B_MappingG_methods.__init__)(((B_Mapping)W_self), ((B_Eq)W_HashableD_A), ((B_Indexed)B_IndexedD_MappingD_dictG_new(W_HashableD_A, ((B_Mapping)W_self))));
     W_self->W_HashableD_AD_MappingD_dict = W_HashableD_A;
@@ -3458,7 +3587,7 @@ void B_MappingD_dictD___serialize__ (B_MappingD_dict self, $Serial$state state)
 B_MappingD_dict B_MappingD_dictD___deserialize__ (B_MappingD_dict self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MappingD_dict));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MappingD_dict), B_MappingD_dictG_methods.$GCdescr);
             self->$class = &B_MappingD_dictG_methods;
             return self;
         }
@@ -3471,12 +3600,13 @@ B_MappingD_dict B_MappingD_dictD___deserialize__ (B_MappingD_dict self, $Serial$
     return self;
 }
 B_MappingD_dict B_MappingD_dictG_new(B_Hashable G_1) {
-    B_MappingD_dict $tmp = malloc(sizeof(struct B_MappingD_dict));
+    B_MappingD_dict $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MappingD_dict), B_MappingD_dictG_methods.$GCdescr);
     $tmp->$class = &B_MappingD_dictG_methods;
     B_MappingD_dictG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_MappingD_dictG_class B_MappingD_dictG_methods;
+GC_word B_MappingD_dictD_gcbm[GC_BITMAP_SIZE(struct B_MappingD_dict)];
 B_NoneType B_IndexedD_MappingD_dictD___init__ (B_IndexedD_MappingD_dict W_self, B_Hashable W_HashableD_A, B_Mapping W_Mapping) {
     ((B_NoneType (*) (B_IndexedD_Mapping, B_Eq, B_Mapping))B_IndexedD_MappingG_methods.__init__)(((B_IndexedD_Mapping)W_self), ((B_Eq)W_HashableD_A), ((B_Mapping)W_Mapping));
     W_self->W_HashableD_AD_MappingD_dict = W_HashableD_A;
@@ -3494,7 +3624,7 @@ void B_IndexedD_MappingD_dictD___serialize__ (B_IndexedD_MappingD_dict self, $Se
 B_IndexedD_MappingD_dict B_IndexedD_MappingD_dictD___deserialize__ (B_IndexedD_MappingD_dict self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IndexedD_MappingD_dict));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexedD_MappingD_dict), B_IndexedD_MappingD_dictG_methods.$GCdescr);
             self->$class = &B_IndexedD_MappingD_dictG_methods;
             return self;
         }
@@ -3507,12 +3637,13 @@ B_IndexedD_MappingD_dict B_IndexedD_MappingD_dictD___deserialize__ (B_IndexedD_M
     return self;
 }
 B_IndexedD_MappingD_dict B_IndexedD_MappingD_dictG_new(B_Hashable G_1, B_Mapping G_2) {
-    B_IndexedD_MappingD_dict $tmp = malloc(sizeof(struct B_IndexedD_MappingD_dict));
+    B_IndexedD_MappingD_dict $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IndexedD_MappingD_dict), B_IndexedD_MappingD_dictG_methods.$GCdescr);
     $tmp->$class = &B_IndexedD_MappingD_dictG_methods;
     B_IndexedD_MappingD_dictG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_IndexedD_MappingD_dictG_class B_IndexedD_MappingD_dictG_methods;
+GC_word B_IndexedD_MappingD_dictD_gcbm[GC_BITMAP_SIZE(struct B_IndexedD_MappingD_dict)];
 B_NoneType B_OrdD_dictD___init__ (B_OrdD_dict W_self, B_Hashable W_HashableD_A, B_Eq W_EqD_B) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     W_self->W_HashableD_AD_OrdD_dict = W_HashableD_A;
@@ -3528,7 +3659,7 @@ void B_OrdD_dictD___serialize__ (B_OrdD_dict self, $Serial$state state) {
 B_OrdD_dict B_OrdD_dictD___deserialize__ (B_OrdD_dict self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_dict));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_dict), B_OrdD_dictG_methods.$GCdescr);
             self->$class = &B_OrdD_dictG_methods;
             return self;
         }
@@ -3539,12 +3670,13 @@ B_OrdD_dict B_OrdD_dictD___deserialize__ (B_OrdD_dict self, $Serial$state state)
     return self;
 }
 B_OrdD_dict B_OrdD_dictG_new(B_Hashable G_1, B_Eq G_2) {
-    B_OrdD_dict $tmp = malloc(sizeof(struct B_OrdD_dict));
+    B_OrdD_dict $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_dict), B_OrdD_dictG_methods.$GCdescr);
     $tmp->$class = &B_OrdD_dictG_methods;
     B_OrdD_dictG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_OrdD_dictG_class B_OrdD_dictG_methods;
+GC_word B_OrdD_dictD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_dict)];
 B_NoneType B_SetD_setD___init__ (B_SetD_set W_self, B_Hashable W_HashableD_A) {
     ((B_NoneType (*) (B_Set, B_Eq, B_Ord, B_Logical, B_Minus))B_SetG_methods.__init__)(((B_Set)W_self), ((B_Eq)W_HashableD_A), ((B_Ord)B_OrdD_SetD_setG_new(W_HashableD_A, ((B_Set)W_self))), ((B_Logical)B_LogicalD_SetD_setG_new(W_HashableD_A, ((B_Set)W_self))), ((B_Minus)B_MinusD_SetD_setG_new(W_HashableD_A, ((B_Set)W_self))));
     W_self->W_HashableD_AD_SetD_set = W_HashableD_A;
@@ -3570,7 +3702,7 @@ void B_SetD_setD___serialize__ (B_SetD_set self, $Serial$state state) {
 B_SetD_set B_SetD_setD___deserialize__ (B_SetD_set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_SetD_set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SetD_set), B_SetD_setG_methods.$GCdescr);
             self->$class = &B_SetD_setG_methods;
             return self;
         }
@@ -3585,12 +3717,13 @@ B_SetD_set B_SetD_setD___deserialize__ (B_SetD_set self, $Serial$state state) {
     return self;
 }
 B_SetD_set B_SetD_setG_new(B_Hashable G_1) {
-    B_SetD_set $tmp = malloc(sizeof(struct B_SetD_set));
+    B_SetD_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SetD_set), B_SetD_setG_methods.$GCdescr);
     $tmp->$class = &B_SetD_setG_methods;
     B_SetD_setG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_SetD_setG_class B_SetD_setG_methods;
+GC_word B_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_SetD_set)];
 B_NoneType B_OrdD_SetD_setD___init__ (B_OrdD_SetD_set W_self, B_Hashable W_HashableD_A, B_Set W_Set) {
     ((B_NoneType (*) (B_OrdD_Set, B_Eq, B_Set))B_OrdD_SetG_methods.__init__)(((B_OrdD_Set)W_self), ((B_Eq)W_HashableD_A), ((B_Set)W_Set));
     W_self->W_HashableD_AD_SetD_set = W_HashableD_A;
@@ -3606,7 +3739,7 @@ void B_OrdD_SetD_setD___serialize__ (B_OrdD_SetD_set self, $Serial$state state)
 B_OrdD_SetD_set B_OrdD_SetD_setD___deserialize__ (B_OrdD_SetD_set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_SetD_set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_SetD_set), B_OrdD_SetD_setG_methods.$GCdescr);
             self->$class = &B_OrdD_SetD_setG_methods;
             return self;
         }
@@ -3618,12 +3751,13 @@ B_OrdD_SetD_set B_OrdD_SetD_setD___deserialize__ (B_OrdD_SetD_set self, $Serial$
     return self;
 }
 B_OrdD_SetD_set B_OrdD_SetD_setG_new(B_Hashable G_1, B_Set G_2) {
-    B_OrdD_SetD_set $tmp = malloc(sizeof(struct B_OrdD_SetD_set));
+    B_OrdD_SetD_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_SetD_set), B_OrdD_SetD_setG_methods.$GCdescr);
     $tmp->$class = &B_OrdD_SetD_setG_methods;
     B_OrdD_SetD_setG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_OrdD_SetD_setG_class B_OrdD_SetD_setG_methods;
+GC_word B_OrdD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_SetD_set)];
 B_NoneType B_LogicalD_SetD_setD___init__ (B_LogicalD_SetD_set W_self, B_Hashable W_HashableD_A, B_Set W_Set) {
     ((B_NoneType (*) (B_LogicalD_Set, B_Eq, B_Set))B_LogicalD_SetG_methods.__init__)(((B_LogicalD_Set)W_self), ((B_Eq)W_HashableD_A), ((B_Set)W_Set));
     W_self->W_HashableD_AD_SetD_set = W_HashableD_A;
@@ -3640,7 +3774,7 @@ void B_LogicalD_SetD_setD___serialize__ (B_LogicalD_SetD_set self, $Serial$state
 B_LogicalD_SetD_set B_LogicalD_SetD_setD___deserialize__ (B_LogicalD_SetD_set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_LogicalD_SetD_set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_SetD_set), B_LogicalD_SetD_setG_methods.$GCdescr);
             self->$class = &B_LogicalD_SetD_setG_methods;
             return self;
         }
@@ -3652,12 +3786,13 @@ B_LogicalD_SetD_set B_LogicalD_SetD_setD___deserialize__ (B_LogicalD_SetD_set se
     return self;
 }
 B_LogicalD_SetD_set B_LogicalD_SetD_setG_new(B_Hashable G_1, B_Set G_2) {
-    B_LogicalD_SetD_set $tmp = malloc(sizeof(struct B_LogicalD_SetD_set));
+    B_LogicalD_SetD_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_LogicalD_SetD_set), B_LogicalD_SetD_setG_methods.$GCdescr);
     $tmp->$class = &B_LogicalD_SetD_setG_methods;
     B_LogicalD_SetD_setG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_LogicalD_SetD_setG_class B_LogicalD_SetD_setG_methods;
+GC_word B_LogicalD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_SetD_set)];
 B_NoneType B_MinusD_SetD_setD___init__ (B_MinusD_SetD_set W_self, B_Hashable W_HashableD_A, B_Set W_Set) {
     ((B_NoneType (*) (B_MinusD_Set, B_Eq, B_Set))B_MinusD_SetG_methods.__init__)(((B_MinusD_Set)W_self), ((B_Eq)W_HashableD_A), ((B_Set)W_Set));
     W_self->W_HashableD_AD_SetD_set = W_HashableD_A;
@@ -3672,7 +3807,7 @@ void B_MinusD_SetD_setD___serialize__ (B_MinusD_SetD_set self, $Serial$state sta
 B_MinusD_SetD_set B_MinusD_SetD_setD___deserialize__ (B_MinusD_SetD_set self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_MinusD_SetD_set));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_SetD_set), B_MinusD_SetD_setG_methods.$GCdescr);
             self->$class = &B_MinusD_SetD_setG_methods;
             return self;
         }
@@ -3684,12 +3819,13 @@ B_MinusD_SetD_set B_MinusD_SetD_setD___deserialize__ (B_MinusD_SetD_set self, $S
     return self;
 }
 B_MinusD_SetD_set B_MinusD_SetD_setG_new(B_Hashable G_1, B_Set G_2) {
-    B_MinusD_SetD_set $tmp = malloc(sizeof(struct B_MinusD_SetD_set));
+    B_MinusD_SetD_set $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_MinusD_SetD_set), B_MinusD_SetD_setG_methods.$GCdescr);
     $tmp->$class = &B_MinusD_SetD_setG_methods;
     B_MinusD_SetD_setG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_MinusD_SetD_setG_class B_MinusD_SetD_setG_methods;
+GC_word B_MinusD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_SetD_set)];
 B_NoneType B_IterableD_IteratorD___init__ (B_IterableD_Iterator W_self) {
     ((B_NoneType (*) (B_Iterable))B_IterableG_methods.__init__)(((B_Iterable)W_self));
     return B_None;
@@ -3700,7 +3836,7 @@ void B_IterableD_IteratorD___serialize__ (B_IterableD_Iterator self, $Serial$sta
 B_IterableD_Iterator B_IterableD_IteratorD___deserialize__ (B_IterableD_Iterator self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IterableD_Iterator));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IterableD_Iterator), B_IterableD_IteratorG_methods.$GCdescr);
             self->$class = &B_IterableD_IteratorG_methods;
             return self;
         }
@@ -3709,12 +3845,13 @@ B_IterableD_Iterator B_IterableD_IteratorD___deserialize__ (B_IterableD_Iterator
     return self;
 }
 B_IterableD_Iterator B_IterableD_IteratorG_new() {
-    B_IterableD_Iterator $tmp = malloc(sizeof(struct B_IterableD_Iterator));
+    B_IterableD_Iterator $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IterableD_Iterator), B_IterableD_IteratorG_methods.$GCdescr);
     $tmp->$class = &B_IterableD_IteratorG_methods;
     B_IterableD_IteratorG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IterableD_IteratorG_class B_IterableD_IteratorG_methods;
+GC_word B_IterableD_IteratorD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_Iterator)];
 B_NoneType B_IterableD_rangeD___init__ (B_IterableD_range W_self) {
     ((B_NoneType (*) (B_Iterable))B_IterableG_methods.__init__)(((B_Iterable)W_self));
     return B_None;
@@ -3725,7 +3862,7 @@ void B_IterableD_rangeD___serialize__ (B_IterableD_range self, $Serial$state sta
 B_IterableD_range B_IterableD_rangeD___deserialize__ (B_IterableD_range self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_IterableD_range));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IterableD_range), B_IterableD_rangeG_methods.$GCdescr);
             self->$class = &B_IterableD_rangeG_methods;
             return self;
         }
@@ -3734,12 +3871,13 @@ B_IterableD_range B_IterableD_rangeD___deserialize__ (B_IterableD_range self, $S
     return self;
 }
 B_IterableD_range B_IterableD_rangeG_new() {
-    B_IterableD_range $tmp = malloc(sizeof(struct B_IterableD_range));
+    B_IterableD_range $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_IterableD_range), B_IterableD_rangeG_methods.$GCdescr);
     $tmp->$class = &B_IterableD_rangeG_methods;
     B_IterableD_rangeG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_IterableD_rangeG_class B_IterableD_rangeG_methods;
+GC_word B_IterableD_rangeD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_range)];
 B_NoneType B_OrdD_strD___init__ (B_OrdD_str W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -3751,7 +3889,7 @@ void B_OrdD_strD___serialize__ (B_OrdD_str self, $Serial$state state) {
 B_OrdD_str B_OrdD_strD___deserialize__ (B_OrdD_str self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_str));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_str), B_OrdD_strG_methods.$GCdescr);
             self->$class = &B_OrdD_strG_methods;
             return self;
         }
@@ -3760,12 +3898,13 @@ B_OrdD_str B_OrdD_strD___deserialize__ (B_OrdD_str self, $Serial$state state) {
     return self;
 }
 B_OrdD_str B_OrdD_strG_new() {
-    B_OrdD_str $tmp = malloc(sizeof(struct B_OrdD_str));
+    B_OrdD_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_str), B_OrdD_strG_methods.$GCdescr);
     $tmp->$class = &B_OrdD_strG_methods;
     B_OrdD_strG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_strG_class B_OrdD_strG_methods;
+GC_word B_OrdD_strD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_str)];
 B_NoneType B_ContainerD_strD___init__ (B_ContainerD_str W_self) {
     B_Eq W_395 = ((B_Eq)B_OrdD_strG_new());
     ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_395);
@@ -3782,7 +3921,7 @@ void B_ContainerD_strD___serialize__ (B_ContainerD_str self, $Serial$state state
 B_ContainerD_str B_ContainerD_strD___deserialize__ (B_ContainerD_str self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_ContainerD_str));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_str), B_ContainerD_strG_methods.$GCdescr);
             self->$class = &B_ContainerD_strG_methods;
             return self;
         }
@@ -3792,12 +3931,13 @@ B_ContainerD_str B_ContainerD_strD___deserialize__ (B_ContainerD_str self, $Seri
     return self;
 }
 B_ContainerD_str B_ContainerD_strG_new() {
-    B_ContainerD_str $tmp = malloc(sizeof(struct B_ContainerD_str));
+    B_ContainerD_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_str), B_ContainerD_strG_methods.$GCdescr);
     $tmp->$class = &B_ContainerD_strG_methods;
     B_ContainerD_strG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_ContainerD_strG_class B_ContainerD_strG_methods;
+GC_word B_ContainerD_strD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_str)];
 B_NoneType B_SliceableD_strD___init__ (B_SliceableD_str W_self) {
     ((B_NoneType (*) (B_Sliceable))B_SliceableG_methods.__init__)(((B_Sliceable)W_self));
     return B_None;
@@ -3814,7 +3954,7 @@ void B_SliceableD_strD___serialize__ (B_SliceableD_str self, $Serial$state state
 B_SliceableD_str B_SliceableD_strD___deserialize__ (B_SliceableD_str self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_SliceableD_str));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SliceableD_str), B_SliceableD_strG_methods.$GCdescr);
             self->$class = &B_SliceableD_strG_methods;
             return self;
         }
@@ -3824,12 +3964,13 @@ B_SliceableD_str B_SliceableD_strD___deserialize__ (B_SliceableD_str self, $Seri
     return self;
 }
 B_SliceableD_str B_SliceableD_strG_new() {
-    B_SliceableD_str $tmp = malloc(sizeof(struct B_SliceableD_str));
+    B_SliceableD_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SliceableD_str), B_SliceableD_strG_methods.$GCdescr);
     $tmp->$class = &B_SliceableD_strG_methods;
     B_SliceableD_strG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_SliceableD_strG_class B_SliceableD_strG_methods;
+GC_word B_SliceableD_strD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_str)];
 B_NoneType B_TimesD_strD___init__ (B_TimesD_str W_self) {
     ((B_NoneType (*) (B_Times))B_TimesG_methods.__init__)(((B_Times)W_self));
     return B_None;
@@ -3841,7 +3982,7 @@ void B_TimesD_strD___serialize__ (B_TimesD_str self, $Serial$state state) {
 B_TimesD_str B_TimesD_strD___deserialize__ (B_TimesD_str self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_TimesD_str));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_str), B_TimesD_strG_methods.$GCdescr);
             self->$class = &B_TimesD_strG_methods;
             return self;
         }
@@ -3850,12 +3991,13 @@ B_TimesD_str B_TimesD_strD___deserialize__ (B_TimesD_str self, $Serial$state sta
     return self;
 }
 B_TimesD_str B_TimesD_strG_new() {
-    B_TimesD_str $tmp = malloc(sizeof(struct B_TimesD_str));
+    B_TimesD_str $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_str), B_TimesD_strG_methods.$GCdescr);
     $tmp->$class = &B_TimesD_strG_methods;
     B_TimesD_strG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_TimesD_strG_class B_TimesD_strG_methods;
+GC_word B_TimesD_strD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_str)];
 B_NoneType B_HashableD_strD___init__ (B_HashableD_str W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -3866,7 +4008,7 @@ void B_HashableD_strD___serialize__ (B_HashableD_str self, $Serial$state state)
 B_HashableD_str B_HashableD_strD___deserialize__ (B_HashableD_str self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_str));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_str), B_HashableD_strG_methods.$GCdescr);
             self->$class = &B_HashableD_strG_methods;
             return self;
         }
@@ -3878,6 +4020,7 @@ B_HashableD_str B_HashableD_strG_new() {   // Manually added.
     return $NEW(B_HashableD_str);          //
 }                                          //
 struct B_HashableD_strG_class B_HashableD_strG_methods;
+GC_word B_HashableD_strD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_str)];
 B_NoneType B_OrdD_bytearrayD___init__ (B_OrdD_bytearray W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -3889,7 +4032,7 @@ void B_OrdD_bytearrayD___serialize__ (B_OrdD_bytearray self, $Serial$state state
 B_OrdD_bytearray B_OrdD_bytearrayD___deserialize__ (B_OrdD_bytearray self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_bytearray));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_bytearray), B_OrdD_bytearrayG_methods.$GCdescr);
             self->$class = &B_OrdD_bytearrayG_methods;
             return self;
         }
@@ -3898,12 +4041,13 @@ B_OrdD_bytearray B_OrdD_bytearrayD___deserialize__ (B_OrdD_bytearray self, $Seri
     return self;
 }
 B_OrdD_bytearray B_OrdD_bytearrayG_new() {
-    B_OrdD_bytearray $tmp = malloc(sizeof(struct B_OrdD_bytearray));
+    B_OrdD_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_bytearray), B_OrdD_bytearrayG_methods.$GCdescr);
     $tmp->$class = &B_OrdD_bytearrayG_methods;
     B_OrdD_bytearrayG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_bytearrayG_class B_OrdD_bytearrayG_methods;
+GC_word B_OrdD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_bytearray)];
 B_NoneType B_SequenceD_bytearrayD___init__ (B_SequenceD_bytearray W_self) {
     ((B_NoneType (*) (B_Sequence, B_Collection, B_Times))B_SequenceG_methods.__init__)(((B_Sequence)W_self), ((B_Collection)B_CollectionD_SequenceD_bytearrayG_new(((B_Sequence)W_self))), ((B_Times)B_TimesD_SequenceD_bytearrayG_new(((B_Sequence)W_self))));
     return B_None;
@@ -3926,7 +4070,7 @@ void B_SequenceD_bytearrayD___serialize__ (B_SequenceD_bytearray self, $Serial$s
 B_SequenceD_bytearray B_SequenceD_bytearrayD___deserialize__ (B_SequenceD_bytearray self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_SequenceD_bytearray));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SequenceD_bytearray), B_SequenceD_bytearrayG_methods.$GCdescr);
             self->$class = &B_SequenceD_bytearrayG_methods;
             return self;
         }
@@ -3938,12 +4082,13 @@ B_SequenceD_bytearray B_SequenceD_bytearrayD___deserialize__ (B_SequenceD_bytear
     return self;
 }
 B_SequenceD_bytearray B_SequenceD_bytearrayG_new() {
-    B_SequenceD_bytearray $tmp = malloc(sizeof(struct B_SequenceD_bytearray));
+    B_SequenceD_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SequenceD_bytearray), B_SequenceD_bytearrayG_methods.$GCdescr);
     $tmp->$class = &B_SequenceD_bytearrayG_methods;
     B_SequenceD_bytearrayG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_SequenceD_bytearrayG_class B_SequenceD_bytearrayG_methods;
+GC_word B_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_SequenceD_bytearray)];
 B_NoneType B_CollectionD_SequenceD_bytearrayD___init__ (B_CollectionD_SequenceD_bytearray W_self, B_Sequence W_Sequence) {
     ((B_NoneType (*) (B_CollectionD_Sequence, B_Sequence))B_CollectionD_SequenceG_methods.__init__)(((B_CollectionD_Sequence)W_self), ((B_Sequence)W_Sequence));
     return B_None;
@@ -3957,7 +4102,7 @@ void B_CollectionD_SequenceD_bytearrayD___serialize__ (B_CollectionD_SequenceD_b
 B_CollectionD_SequenceD_bytearray B_CollectionD_SequenceD_bytearrayD___deserialize__ (B_CollectionD_SequenceD_bytearray self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_CollectionD_SequenceD_bytearray));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_SequenceD_bytearray), B_CollectionD_SequenceD_bytearrayG_methods.$GCdescr);
             self->$class = &B_CollectionD_SequenceD_bytearrayG_methods;
             return self;
         }
@@ -3967,12 +4112,13 @@ B_CollectionD_SequenceD_bytearray B_CollectionD_SequenceD_bytearrayD___deseriali
     return self;
 }
 B_CollectionD_SequenceD_bytearray B_CollectionD_SequenceD_bytearrayG_new(B_Sequence G_1) {
-    B_CollectionD_SequenceD_bytearray $tmp = malloc(sizeof(struct B_CollectionD_SequenceD_bytearray));
+    B_CollectionD_SequenceD_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_CollectionD_SequenceD_bytearray), B_CollectionD_SequenceD_bytearrayG_methods.$GCdescr);
     $tmp->$class = &B_CollectionD_SequenceD_bytearrayG_methods;
     B_CollectionD_SequenceD_bytearrayG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_CollectionD_SequenceD_bytearrayG_class B_CollectionD_SequenceD_bytearrayG_methods;
+GC_word B_CollectionD_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_SequenceD_bytearray)];
 B_NoneType B_TimesD_SequenceD_bytearrayD___init__ (B_TimesD_SequenceD_bytearray W_self, B_Sequence W_Sequence) {
     ((B_NoneType (*) (B_TimesD_Sequence, B_Sequence))B_TimesD_SequenceG_methods.__init__)(((B_TimesD_Sequence)W_self), ((B_Sequence)W_Sequence));
     return B_None;
@@ -3985,7 +4131,7 @@ void B_TimesD_SequenceD_bytearrayD___serialize__ (B_TimesD_SequenceD_bytearray s
 B_TimesD_SequenceD_bytearray B_TimesD_SequenceD_bytearrayD___deserialize__ (B_TimesD_SequenceD_bytearray self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_TimesD_SequenceD_bytearray));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_SequenceD_bytearray), B_TimesD_SequenceD_bytearrayG_methods.$GCdescr);
             self->$class = &B_TimesD_SequenceD_bytearrayG_methods;
             return self;
         }
@@ -3995,12 +4141,13 @@ B_TimesD_SequenceD_bytearray B_TimesD_SequenceD_bytearrayD___deserialize__ (B_Ti
     return self;
 }
 B_TimesD_SequenceD_bytearray B_TimesD_SequenceD_bytearrayG_new(B_Sequence G_1) {
-    B_TimesD_SequenceD_bytearray $tmp = malloc(sizeof(struct B_TimesD_SequenceD_bytearray));
+    B_TimesD_SequenceD_bytearray $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_SequenceD_bytearray), B_TimesD_SequenceD_bytearrayG_methods.$GCdescr);
     $tmp->$class = &B_TimesD_SequenceD_bytearrayG_methods;
     B_TimesD_SequenceD_bytearrayG_methods.__init__($tmp, G_1);
     return $tmp;
 }
 struct B_TimesD_SequenceD_bytearrayG_class B_TimesD_SequenceD_bytearrayG_methods;
+GC_word B_TimesD_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_SequenceD_bytearray)];
 B_NoneType B_ContainerD_bytearrayD___init__ (B_ContainerD_bytearray W_self) {
     B_Eq W_427 = ((B_Eq)B_OrdD_intG_new());
     ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_427);
@@ -4014,7 +4161,7 @@ void B_ContainerD_bytearrayD___serialize__ (B_ContainerD_bytearray self, $Serial
 B_ContainerD_bytearray B_ContainerD_bytearrayD___deserialize__ (B_ContainerD_bytearray self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_ContainerD_bytearray));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_bytearray), B_ContainerD_bytearrayG_methods.$GCdescr);
             self->$class = &B_ContainerD_bytearrayG_methods;
             return self;
         }
@@ -4024,6 +4171,7 @@ B_ContainerD_bytearray B_ContainerD_bytearrayD___deserialize__ (B_ContainerD_byt
     return self;
 }
 struct B_ContainerD_bytearrayG_class B_ContainerD_bytearrayG_methods;
+GC_word B_ContainerD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_bytearray)];
 B_NoneType B_OrdD_bytesD___init__ (B_OrdD_bytes W_self) {
     ((B_NoneType (*) (B_Ord))B_OrdG_methods.__init__)(((B_Ord)W_self));
     return B_None;
@@ -4035,7 +4183,7 @@ void B_OrdD_bytesD___serialize__ (B_OrdD_bytes self, $Serial$state state) {
 B_OrdD_bytes B_OrdD_bytesD___deserialize__ (B_OrdD_bytes self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_OrdD_bytes));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_bytes), B_OrdD_bytesG_methods.$GCdescr);
             self->$class = &B_OrdD_bytesG_methods;
             return self;
         }
@@ -4044,12 +4192,13 @@ B_OrdD_bytes B_OrdD_bytesD___deserialize__ (B_OrdD_bytes self, $Serial$state sta
     return self;
 }
 B_OrdD_bytes B_OrdD_bytesG_new() {
-    B_OrdD_bytes $tmp = malloc(sizeof(struct B_OrdD_bytes));
+    B_OrdD_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_OrdD_bytes), B_OrdD_bytesG_methods.$GCdescr);
     $tmp->$class = &B_OrdD_bytesG_methods;
     B_OrdD_bytesG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_OrdD_bytesG_class B_OrdD_bytesG_methods;
+GC_word B_OrdD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_bytes)];
 B_NoneType B_SliceableD_bytesD___init__ (B_SliceableD_bytes W_self) {
     ((B_NoneType (*) (B_Sliceable))B_SliceableG_methods.__init__)(((B_Sliceable)W_self));
     return B_None;
@@ -4066,7 +4215,7 @@ void B_SliceableD_bytesD___serialize__ (B_SliceableD_bytes self, $Serial$state s
 B_SliceableD_bytes B_SliceableD_bytesD___deserialize__ (B_SliceableD_bytes self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_SliceableD_bytes));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SliceableD_bytes), B_SliceableD_bytesG_methods.$GCdescr);
             self->$class = &B_SliceableD_bytesG_methods;
             return self;
         }
@@ -4076,12 +4225,13 @@ B_SliceableD_bytes B_SliceableD_bytesD___deserialize__ (B_SliceableD_bytes self,
     return self;
 }
 B_SliceableD_bytes B_SliceableD_bytesG_new() {
-    B_SliceableD_bytes $tmp = malloc(sizeof(struct B_SliceableD_bytes));
+    B_SliceableD_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_SliceableD_bytes), B_SliceableD_bytesG_methods.$GCdescr);
     $tmp->$class = &B_SliceableD_bytesG_methods;
     B_SliceableD_bytesG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_SliceableD_bytesG_class B_SliceableD_bytesG_methods;
+GC_word B_SliceableD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_bytes)];
 B_NoneType B_ContainerD_bytesD___init__ (B_ContainerD_bytes W_self) {
     B_Eq W_438 = ((B_Eq)B_OrdD_intG_new());
     ((B_NoneType (*) (B_Container, B_Eq))B_ContainerG_methods.__init__)(((B_Container)W_self), W_438);
@@ -4098,7 +4248,7 @@ void B_ContainerD_bytesD___serialize__ (B_ContainerD_bytes self, $Serial$state s
 B_ContainerD_bytes B_ContainerD_bytesD___deserialize__ (B_ContainerD_bytes self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_ContainerD_bytes));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_bytes), B_ContainerD_bytesG_methods.$GCdescr);
             self->$class = &B_ContainerD_bytesG_methods;
             return self;
         }
@@ -4108,12 +4258,13 @@ B_ContainerD_bytes B_ContainerD_bytesD___deserialize__ (B_ContainerD_bytes self,
     return self;
 }
 B_ContainerD_bytes B_ContainerD_bytesG_new() {
-    B_ContainerD_bytes $tmp = malloc(sizeof(struct B_ContainerD_bytes));
+    B_ContainerD_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_ContainerD_bytes), B_ContainerD_bytesG_methods.$GCdescr);
     $tmp->$class = &B_ContainerD_bytesG_methods;
     B_ContainerD_bytesG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_ContainerD_bytesG_class B_ContainerD_bytesG_methods;
+GC_word B_ContainerD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_bytes)];
 B_NoneType B_TimesD_bytesD___init__ (B_TimesD_bytes W_self) {
     ((B_NoneType (*) (B_Times))B_TimesG_methods.__init__)(((B_Times)W_self));
     return B_None;
@@ -4125,7 +4276,7 @@ void B_TimesD_bytesD___serialize__ (B_TimesD_bytes self, $Serial$state state) {
 B_TimesD_bytes B_TimesD_bytesD___deserialize__ (B_TimesD_bytes self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_TimesD_bytes));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_bytes), B_TimesD_bytesG_methods.$GCdescr);
             self->$class = &B_TimesD_bytesG_methods;
             return self;
         }
@@ -4134,12 +4285,13 @@ B_TimesD_bytes B_TimesD_bytesD___deserialize__ (B_TimesD_bytes self, $Serial$sta
     return self;
 }
 B_TimesD_bytes B_TimesD_bytesG_new() {
-    B_TimesD_bytes $tmp = malloc(sizeof(struct B_TimesD_bytes));
+    B_TimesD_bytes $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_TimesD_bytes), B_TimesD_bytesG_methods.$GCdescr);
     $tmp->$class = &B_TimesD_bytesG_methods;
     B_TimesD_bytesG_methods.__init__($tmp);
     return $tmp;
 }
 struct B_TimesD_bytesG_class B_TimesD_bytesG_methods;
+GC_word B_TimesD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_bytes)];
 B_NoneType B_HashableD_bytesD___init__ (B_HashableD_bytes W_self) {
     ((B_NoneType (*) (B_Hashable))B_HashableG_methods.__init__)(((B_Hashable)W_self));
     return B_None;
@@ -4150,7 +4302,7 @@ void B_HashableD_bytesD___serialize__ (B_HashableD_bytes self, $Serial$state sta
 B_HashableD_bytes B_HashableD_bytesD___deserialize__ (B_HashableD_bytes self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_HashableD_bytes));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_HashableD_bytes), B_HashableD_bytesG_methods.$GCdescr);
             self->$class = &B_HashableD_bytesG_methods;
             return self;
         }
@@ -4159,6 +4311,7 @@ B_HashableD_bytes B_HashableD_bytesD___deserialize__ (B_HashableD_bytes self, $S
     return self;
 }
 struct B_HashableD_bytesG_class B_HashableD_bytesG_methods;
+GC_word B_HashableD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_bytes)];
 $WORD B_abs (B_Real W_RealE_768, B_Number W_NumberE_767, $WORD x) {
     return (($WORD (*) (B_Number, $WORD, B_Real))W_NumberE_767->$class->__abs__)(W_NumberE_767, x, W_RealE_768);
 }
@@ -4254,7 +4407,7 @@ void B_L_1procD___serialize__ (B_L_1proc self, $Serial$state state) {
 B_L_1proc B_L_1procD___deserialize__ (B_L_1proc self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_L_1proc));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_1proc), B_L_1procG_methods.$GCdescr);
             self->$class = &B_L_1procG_methods;
             return self;
         }
@@ -4265,12 +4418,13 @@ B_L_1proc B_L_1procD___deserialize__ (B_L_1proc self, $Serial$state state) {
     return self;
 }
 B_L_1proc B_L_1procG_new(B_Env G_1, B_str G_2) {
-    B_L_1proc $tmp = malloc(sizeof(struct B_L_1proc));
+    B_L_1proc $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_1proc), B_L_1procG_methods.$GCdescr);
     $tmp->$class = &B_L_1procG_methods;
     B_L_1procG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_L_1procG_class B_L_1procG_methods;
+GC_word B_L_1procD_gcbm[GC_BITMAP_SIZE(struct B_L_1proc)];
 B_NoneType B_L_2procD___init__ (B_L_2proc L_self, B_Env self, $action cb) {
     L_self->self = self;
     L_self->cb = cb;
@@ -4291,7 +4445,7 @@ void B_L_2procD___serialize__ (B_L_2proc self, $Serial$state state) {
 B_L_2proc B_L_2procD___deserialize__ (B_L_2proc self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_L_2proc));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_2proc), B_L_2procG_methods.$GCdescr);
             self->$class = &B_L_2procG_methods;
             return self;
         }
@@ -4302,12 +4456,13 @@ B_L_2proc B_L_2procD___deserialize__ (B_L_2proc self, $Serial$state state) {
     return self;
 }
 B_L_2proc B_L_2procG_new(B_Env G_1, $action G_2) {
-    B_L_2proc $tmp = malloc(sizeof(struct B_L_2proc));
+    B_L_2proc $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_2proc), B_L_2procG_methods.$GCdescr);
     $tmp->$class = &B_L_2procG_methods;
     B_L_2procG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_L_2procG_class B_L_2procG_methods;
+GC_word B_L_2procD_gcbm[GC_BITMAP_SIZE(struct B_L_2proc)];
 B_NoneType B_L_3procD___init__ (B_L_3proc L_self, B_Env self, B_int n) {
     L_self->self = self;
     L_self->n = n;
@@ -4328,7 +4483,7 @@ void B_L_3procD___serialize__ (B_L_3proc self, $Serial$state state) {
 B_L_3proc B_L_3procD___deserialize__ (B_L_3proc self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_L_3proc));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_3proc), B_L_3procG_methods.$GCdescr);
             self->$class = &B_L_3procG_methods;
             return self;
         }
@@ -4339,12 +4494,13 @@ B_L_3proc B_L_3procD___deserialize__ (B_L_3proc self, $Serial$state state) {
     return self;
 }
 B_L_3proc B_L_3procG_new(B_Env G_1, B_int G_2) {
-    B_L_3proc $tmp = malloc(sizeof(struct B_L_3proc));
+    B_L_3proc $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_3proc), B_L_3procG_methods.$GCdescr);
     $tmp->$class = &B_L_3procG_methods;
     B_L_3procG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_L_3procG_class B_L_3procG_methods;
+GC_word B_L_3procD_gcbm[GC_BITMAP_SIZE(struct B_L_3proc)];
 $R B_L_4C_1cont (B_Env G_act, $Cont C_cont, B_NoneType C_2res) {
     return $RU_CONT(C_cont, G_act);
 }
@@ -4365,7 +4521,7 @@ void B_L_5ContD___serialize__ (B_L_5Cont self, $Serial$state state) {
 B_L_5Cont B_L_5ContD___deserialize__ (B_L_5Cont self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_L_5Cont));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_5Cont), B_L_5ContG_methods.$GCdescr);
             self->$class = &B_L_5ContG_methods;
             return self;
         }
@@ -4376,12 +4532,13 @@ B_L_5Cont B_L_5ContD___deserialize__ (B_L_5Cont self, $Serial$state state) {
     return self;
 }
 B_L_5Cont B_L_5ContG_new(B_Env G_1, $Cont G_2) {
-    B_L_5Cont $tmp = malloc(sizeof(struct B_L_5Cont));
+    B_L_5Cont $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_5Cont), B_L_5ContG_methods.$GCdescr);
     $tmp->$class = &B_L_5ContG_methods;
     B_L_5ContG_methods.__init__($tmp, G_1, G_2);
     return $tmp;
 }
 struct B_L_5ContG_class B_L_5ContG_methods;
+GC_word B_L_5ContD_gcbm[GC_BITMAP_SIZE(struct B_L_5Cont)];
 B_NoneType B_L_6procD___init__ (B_L_6proc L_self, B_Env G_act, B_WorldAuth token, B_list args) {
     L_self->G_act = G_act;
     L_self->token = token;
@@ -4405,7 +4562,7 @@ void B_L_6procD___serialize__ (B_L_6proc self, $Serial$state state) {
 B_L_6proc B_L_6procD___deserialize__ (B_L_6proc self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_L_6proc));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_6proc), B_L_6procG_methods.$GCdescr);
             self->$class = &B_L_6procG_methods;
             return self;
         }
@@ -4417,18 +4574,19 @@ B_L_6proc B_L_6procD___deserialize__ (B_L_6proc self, $Serial$state state) {
     return self;
 }
 B_L_6proc B_L_6procG_new(B_Env G_1, B_WorldAuth G_2, B_list G_3) {
-    B_L_6proc $tmp = malloc(sizeof(struct B_L_6proc));
+    B_L_6proc $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_L_6proc), B_L_6procG_methods.$GCdescr);
     $tmp->$class = &B_L_6procG_methods;
     B_L_6procG_methods.__init__($tmp, G_1, G_2, G_3);
     return $tmp;
 }
 struct B_L_6procG_class B_L_6procG_methods;
+GC_word B_L_6procD_gcbm[GC_BITMAP_SIZE(struct B_L_6proc)];
 void B_WorldAuthD___serialize__ (B_WorldAuth self, $Serial$state state) {
 }
 B_WorldAuth B_WorldAuthD___deserialize__ (B_WorldAuth self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_WorldAuth));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_WorldAuth), B_WorldAuthG_methods.$GCdescr);
             self->$class = &B_WorldAuthG_methods;
             return self;
         }
@@ -4437,6 +4595,7 @@ B_WorldAuth B_WorldAuthD___deserialize__ (B_WorldAuth self, $Serial$state state)
     return self;
 }
 struct B_WorldAuthG_class B_WorldAuthG_methods;
+GC_word B_WorldAuthD_gcbm[GC_BITMAP_SIZE(struct B_WorldAuth)];
 $R B_EnvD___init__ (B_Env self, $Cont C_cont, B_WorldAuth token, B_list args) {
     self->token = token;
     self->args = args;
@@ -4466,7 +4625,7 @@ void B_EnvD___serialize__ (B_Env self, $Serial$state state) {
 B_Env B_EnvD___deserialize__ (B_Env self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Env));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Env), B_EnvG_methods.$GCdescr);
             self->$class = &B_EnvG_methods;
             return self;
         }
@@ -4480,11 +4639,12 @@ B_Env B_EnvD___deserialize__ (B_Env self, $Serial$state state) {
     return self;
 }
 $R B_EnvG_new($Cont G_1, B_WorldAuth G_2, B_list G_3) {
-    B_Env $tmp = malloc(sizeof(struct B_Env));
+    B_Env $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Env), B_EnvG_methods.$GCdescr);
     $tmp->$class = &B_EnvG_methods;
     return B_EnvG_methods.__init__($tmp, G_1, G_2, $CONSTCONT(G_3, $tmp));
 }
 struct B_EnvG_class B_EnvG_methods;
+GC_word B_EnvD_gcbm[GC_BITMAP_SIZE(struct B_Env)];
 $R B_EnvG_newact ($Cont C_cont, B_WorldAuth token, B_list args) {
     B_Env G_act = $NEWACTOR(B_Env);
     return $AWAIT((($Cont)B_L_5ContG_new(G_act, C_cont)), $ASYNC((($Actor)G_act), (($Cont)B_L_6procG_new(G_act, token, args))));
@@ -4496,7 +4656,9 @@ void B___init__ () {
     B_done$ = 1;
     //    B___ext_init__ ();
     {
-        B_valueG_methods.$GCINFO = "B_value";
+        memset(B_valueD_gcbm, 0xFF, sizeof(B_valueD_gcbm));
+        B_valueG_methods.$GCdescr = GC_make_descriptor(B_valueD_gcbm, GC_WORD_LEN(struct B_value));
+        B_valueG_methods.$name = "B_value";
         B_valueG_methods.$superclass = NULL;
         B_valueG_methods.__init__ = B_valueD___init__;
         B_valueG_methods.__bool__ = B_valueD___bool__;
@@ -4506,7 +4668,9 @@ void B___init__ () {
         B_valueG_methods.__deserialize__ = B_valueD___deserialize__;
     }
     {
-        B_objectG_methods.$GCINFO = "B_object";
+        memset(B_objectD_gcbm, 0xFF, sizeof(B_objectD_gcbm));
+        B_objectG_methods.$GCdescr = GC_make_descriptor(B_objectD_gcbm, GC_WORD_LEN(struct B_object));
+        B_objectG_methods.$name = "B_object";
         B_objectG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_objectG_methods.__init__ = (B_NoneType (*) (B_object))B_valueG_methods.__init__;
         B_objectG_methods.__bool__ = (B_bool (*) (B_object))B_valueG_methods.__bool__;
@@ -4516,7 +4680,9 @@ void B___init__ () {
         B_objectG_methods.__deserialize__ = B_objectD___deserialize__;
     }
     {
-        B_atomG_methods.$GCINFO = "B_atom";
+        memset(B_atomD_gcbm, 0xFF, sizeof(B_atomD_gcbm));
+        B_atomG_methods.$GCdescr = GC_make_descriptor(B_atomD_gcbm, GC_WORD_LEN(struct B_atom));
+        B_atomG_methods.$name = "B_atom";
         B_atomG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_atomG_methods.__init__ = (B_NoneType (*) (B_atom))B_valueG_methods.__init__;
         B_atomG_methods.__bool__ = (B_bool (*) (B_atom))B_valueG_methods.__bool__;
@@ -4526,7 +4692,9 @@ void B___init__ () {
         B_atomG_methods.__deserialize__ = B_atomD___deserialize__;
     }
     {
-        B_intG_methods.$GCINFO = "B_int";
+        memset(B_intD_gcbm, 0xFF, sizeof(B_intD_gcbm));
+        B_intG_methods.$GCdescr = GC_make_descriptor(B_intD_gcbm, GC_WORD_LEN(struct B_int));
+        B_intG_methods.$name = "B_int";
         B_intG_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_intG_methods.__bool__ = B_intD___bool__;
         B_intG_methods.__str__ = B_intD___str__;
@@ -4536,7 +4704,9 @@ void B___init__ () {
         B_intG_methods.__deserialize__ = B_intD___deserialize__;
     }
     {
-        B_i64G_methods.$GCINFO = "B_i64";
+        memset(B_i64D_gcbm, 0xFF, sizeof(B_i64D_gcbm));
+        B_i64G_methods.$GCdescr = GC_make_descriptor(B_i64D_gcbm, GC_WORD_LEN(struct B_i64));
+        B_i64G_methods.$name = "B_i64";
         B_i64G_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_i64G_methods.__bool__ = B_i64D___bool__;
         B_i64G_methods.__str__ = B_i64D___str__;  
@@ -4546,7 +4716,9 @@ void B___init__ () {
         B_i64G_methods.__deserialize__ = B_i64D___deserialize__;
     }
      {
-        B_i32G_methods.$GCINFO = "B_i32";
+        memset(B_i32D_gcbm, 0xFF, sizeof(B_i32D_gcbm));
+        B_i32G_methods.$GCdescr = GC_make_descriptor(B_i32D_gcbm, GC_WORD_LEN(struct B_i32));
+        B_i32G_methods.$name = "B_i32";
         B_i32G_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_i32G_methods.__bool__ = B_i32D___bool__;
         B_i32G_methods.__str__ = B_i32D___str__;  
@@ -4556,7 +4728,9 @@ void B___init__ () {
         B_i32G_methods.__deserialize__ = B_i32D___deserialize__;
     }
      {
-        B_i16G_methods.$GCINFO = "B_i16";
+        memset(B_i16D_gcbm, 0xFF, sizeof(B_i16D_gcbm));
+        B_i16G_methods.$GCdescr = GC_make_descriptor(B_i16D_gcbm, GC_WORD_LEN(struct B_i16));
+        B_i16G_methods.$name = "B_i16";
         B_i16G_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_i16G_methods.__bool__ = B_i16D___bool__;
         B_i16G_methods.__str__ = B_i16D___str__;  
@@ -4566,7 +4740,9 @@ void B___init__ () {
         B_i16G_methods.__deserialize__ = B_i16D___deserialize__;
     }
     {
-        B_u64G_methods.$GCINFO = "B_u64";
+        memset(B_u64D_gcbm, 0xFF, sizeof(B_u64D_gcbm));
+        B_u64G_methods.$GCdescr = GC_make_descriptor(B_u64D_gcbm, GC_WORD_LEN(struct B_u64));
+        B_u64G_methods.$name = "B_u64";
         B_u64G_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_u64G_methods.__bool__ = B_u64D___bool__;
         B_u64G_methods.__str__ = B_u64D___str__;  
@@ -4576,7 +4752,9 @@ void B___init__ () {
         B_u64G_methods.__deserialize__ = B_u64D___deserialize__;
     }
     {
-        B_u32G_methods.$GCINFO = "B_u32";
+        memset(B_u32D_gcbm, 0xFF, sizeof(B_u32D_gcbm));
+        B_u32G_methods.$GCdescr = GC_make_descriptor(B_u32D_gcbm, GC_WORD_LEN(struct B_u32));
+        B_u32G_methods.$name = "B_u32";
         B_u32G_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_u32G_methods.__bool__ = B_u32D___bool__;
         B_u32G_methods.__str__ = B_u32D___str__;  
@@ -4586,7 +4764,9 @@ void B___init__ () {
         B_u32G_methods.__deserialize__ = B_u32D___deserialize__;
     }
     {
-        B_u16G_methods.$GCINFO = "B_u16";
+        memset(B_u16D_gcbm, 0xFF, sizeof(B_u16D_gcbm));
+        B_u16G_methods.$GCdescr = GC_make_descriptor(B_u16D_gcbm, GC_WORD_LEN(struct B_u16));
+        B_u16G_methods.$name = "B_u16";
         B_u16G_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_u16G_methods.__bool__ = B_u16D___bool__;
         B_u16G_methods.__str__ = B_u16D___str__;  
@@ -4596,7 +4776,9 @@ void B___init__ () {
         B_u16G_methods.__deserialize__ = B_u16D___deserialize__;
     }
     {
-        B_floatG_methods.$GCINFO = "B_float";
+        memset(B_floatD_gcbm, 0xFF, sizeof(B_floatD_gcbm));
+        B_floatG_methods.$GCdescr = GC_make_descriptor(B_floatD_gcbm, GC_WORD_LEN(struct B_float));
+        B_floatG_methods.$name = "B_float";
         B_floatG_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_floatG_methods.__bool__ = B_floatD___bool__;
         B_floatG_methods.__str__ = B_floatD___str__;
@@ -4606,7 +4788,9 @@ void B___init__ () {
         B_floatG_methods.__deserialize__ = B_floatD___deserialize__;
     }
     {
-        B_boolG_methods.$GCINFO = "B_bool";
+        memset(B_boolD_gcbm, 0xFF, sizeof(B_boolD_gcbm));
+        B_boolG_methods.$GCdescr = GC_make_descriptor(B_boolD_gcbm, GC_WORD_LEN(struct B_bool));
+        B_boolG_methods.$name = "B_bool";
         B_boolG_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_boolG_methods.__bool__ = B_boolD___bool__;
         B_boolG_methods.__str__ = B_boolD___str__;
@@ -4616,7 +4800,9 @@ void B___init__ () {
         B_boolG_methods.__deserialize__ = B_boolD___deserialize__;
     }
     {
-        B_sliceG_methods.$GCINFO = "B_slice";
+        memset(B_sliceD_gcbm, 0xFF, sizeof(B_sliceD_gcbm));
+        B_sliceG_methods.$GCdescr = GC_make_descriptor(B_sliceD_gcbm, GC_WORD_LEN(struct B_slice));
+        B_sliceG_methods.$name = "B_slice";
         B_sliceG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_sliceG_methods.__bool__ = (B_bool (*) (B_slice))B_valueG_methods.__bool__;
         B_sliceG_methods.__str__ = (B_str (*) (B_slice))B_valueG_methods.__str__;
@@ -4626,7 +4812,9 @@ void B___init__ () {
         B_sliceG_methods.__deserialize__ = B_sliceD___deserialize__;
     }
     {
-        B_listG_methods.$GCINFO = "B_list";
+        memset(B_listD_gcbm, 0xFF, sizeof(B_listD_gcbm));
+        B_listG_methods.$GCdescr = GC_make_descriptor(B_listD_gcbm, GC_WORD_LEN(struct B_list));
+        B_listG_methods.$name = "B_list";
         B_listG_methods.$superclass = ($SuperG_class)&B_objectG_methods;
         B_listG_methods.__bool__ = B_listD___bool__;
         B_listG_methods.__str__ = B_listD___str__;
@@ -4640,7 +4828,9 @@ void B___init__ () {
         B_listG_methods.pop = B_listD_pop;
     }
     {
-        B_rangeG_methods.$GCINFO = "B_range";
+        memset(B_rangeD_gcbm, 0xFF, sizeof(B_rangeD_gcbm));
+        B_rangeG_methods.$GCdescr = GC_make_descriptor(B_rangeD_gcbm, GC_WORD_LEN(struct B_range));
+        B_rangeG_methods.$name = "B_range";
         B_rangeG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_rangeG_methods.__bool__ = (B_bool (*) (B_range))B_valueG_methods.__bool__;
         B_rangeG_methods.__str__ = (B_str (*) (B_range))B_valueG_methods.__str__;
@@ -4650,7 +4840,9 @@ void B___init__ () {
         B_rangeG_methods.__deserialize__ = B_rangeD___deserialize__;
     }
     {
-        B_IteratorG_methods.$GCINFO = "B_Iterator";
+        memset(B_IteratorD_gcbm, 0xFF, sizeof(B_IteratorD_gcbm));
+        B_IteratorG_methods.$GCdescr = GC_make_descriptor(B_IteratorD_gcbm, GC_WORD_LEN(struct B_Iterator));
+        B_IteratorG_methods.$name = "B_Iterator";
         B_IteratorG_methods.$superclass = ($SuperG_class)&B_objectG_methods;
         B_IteratorG_methods.__bool__ = (B_bool (*) (B_Iterator))B_valueG_methods.__bool__;
         B_IteratorG_methods.__str__ = (B_str (*) (B_Iterator))B_valueG_methods.__str__;
@@ -4659,7 +4851,9 @@ void B___init__ () {
         B_IteratorG_methods.__deserialize__ = B_IteratorD___deserialize__;
     }
     {
-        B_IterableG_methods.$GCINFO = "B_Iterable";
+        memset(B_IterableD_gcbm, 0xFF, sizeof(B_IterableD_gcbm));
+        B_IterableG_methods.$GCdescr = GC_make_descriptor(B_IterableD_gcbm, GC_WORD_LEN(struct B_Iterable));
+        B_IterableG_methods.$name = "B_Iterable";
         B_IterableG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_IterableG_methods.__bool__ = (B_bool (*) (B_Iterable))B_valueG_methods.__bool__;
         B_IterableG_methods.__str__ = (B_str (*) (B_Iterable))B_valueG_methods.__str__;
@@ -4670,7 +4864,9 @@ void B___init__ () {
         $register(&B_IterableG_methods);
     }
     {
-        B_strG_methods.$GCINFO = "B_str";
+        memset(B_strD_gcbm, 0xFF, sizeof(B_strD_gcbm));
+        B_strG_methods.$GCdescr = GC_make_descriptor(B_strD_gcbm, GC_WORD_LEN(struct B_str));
+        B_strG_methods.$name = "B_str";
         B_strG_methods.$superclass = ($SuperG_class)&B_atomG_methods;
         B_strG_methods.__bool__ = (B_bool (*) (B_str))B_valueG_methods.__bool__;
         B_strG_methods.__str__ = B_strD___str__;
@@ -4714,7 +4910,9 @@ void B___init__ () {
         B_strG_methods.__deserialize__ = B_strD___deserialize__;
     }
     {
-        B_bytesG_methods.$GCINFO = "B_bytes";
+        memset(B_bytesD_gcbm, 0xFF, sizeof(B_bytesD_gcbm));
+        B_bytesG_methods.$GCdescr = GC_make_descriptor(B_bytesD_gcbm, GC_WORD_LEN(struct B_bytes));
+        B_bytesG_methods.$name = "B_bytes";
         B_bytesG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_bytesG_methods.__bool__ = (B_bool (*) (B_bytes))B_valueG_methods.__bool__;
         B_bytesG_methods.__str__ = B_bytesD___str__;
@@ -4757,7 +4955,9 @@ void B___init__ () {
         B_bytesG_methods.__deserialize__ = B_bytesD___deserialize__;
     }
     {
-        B_bytearrayG_methods.$GCINFO = "B_bytearray";
+        memset(B_bytearrayD_gcbm, 0xFF, sizeof(B_bytearrayD_gcbm));
+        B_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_bytearrayD_gcbm, GC_WORD_LEN(struct B_bytearray));
+        B_bytearrayG_methods.$name = "B_bytearray";
         B_bytearrayG_methods.$superclass = ($SuperG_class)&B_objectG_methods;
         B_bytearrayG_methods.__bool__ = (B_bool (*) (B_bytearray))B_valueG_methods.__bool__;
         B_bytearrayG_methods.__str__ = B_bytearrayD___str__;
@@ -4801,7 +5001,9 @@ void B___init__ () {
     }
     /*
     {
-        B_MsgG_methods.$GCINFO = "B_Msg";
+        memset(B_MsgD_gcbm, 0xFF, sizeof(B_MsgD_gcbm));
+        B_MsgG_methods.$GCdescr = GC_make_descriptor(B_MsgD_gcbm, GC_WORD_LEN(struct B_Msg));
+        B_MsgG_methods.$name = "B_Msg";
         B_MsgG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_MsgG_methods.__bool__ = (B_bool (*) (B_Msg))B_valueG_methods.__bool__;
         B_MsgG_methods.__str__ = (B_str (*) (B_Msg))B_valueG_methods.__str__;
@@ -4812,7 +5014,9 @@ void B___init__ () {
     }
     */
     {
-        B_BaseExceptionG_methods.$GCINFO = "B_BaseException";
+        memset(B_BaseExceptionD_gcbm, 0xFF, sizeof(B_BaseExceptionD_gcbm));
+        B_BaseExceptionG_methods.$GCdescr = GC_make_descriptor(B_BaseExceptionD_gcbm, GC_WORD_LEN(struct B_BaseException));
+        B_BaseExceptionG_methods.$name = "B_BaseException";
         B_BaseExceptionG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_BaseExceptionG_methods.__bool__ = (B_bool (*) (B_BaseException))B_valueG_methods.__bool__;
         B_BaseExceptionG_methods.__str__ = B_BaseExceptionD___str__;
@@ -4822,7 +5026,9 @@ void B___init__ () {
         B_BaseExceptionG_methods.__deserialize__ = B_BaseExceptionD___deserialize__; 
     }
     {
-        B_SystemExitG_methods.$GCINFO = "B_SystemExit";
+        memset(B_SystemExitD_gcbm, 0xFF, sizeof(B_SystemExitD_gcbm));
+        B_SystemExitG_methods.$GCdescr = GC_make_descriptor(B_SystemExitD_gcbm, GC_WORD_LEN(struct B_SystemExit));
+        B_SystemExitG_methods.$name = "B_SystemExit";
         B_SystemExitG_methods.$superclass = ($SuperG_class)&B_BaseExceptionG_methods;
         B_SystemExitG_methods.__init__ = (B_NoneType (*) (B_SystemExit, B_str))B_BaseExceptionG_methods.__init__;
         B_SystemExitG_methods.__bool__ = (B_bool (*) (B_SystemExit))B_valueG_methods.__bool__;
@@ -4832,7 +5038,9 @@ void B___init__ () {
         B_SystemExitG_methods.__deserialize__ = B_SystemExitD___deserialize__;
     }
     {
-        B_KeyboardInterruptG_methods.$GCINFO = "B_KeyboardInterrupt";
+        memset(B_KeyboardInterruptD_gcbm, 0xFF, sizeof(B_KeyboardInterruptD_gcbm));
+        B_KeyboardInterruptG_methods.$GCdescr = GC_make_descriptor(B_KeyboardInterruptD_gcbm, GC_WORD_LEN(struct B_KeyboardInterrupt));
+        B_KeyboardInterruptG_methods.$name = "B_KeyboardInterrupt";
         B_KeyboardInterruptG_methods.$superclass = ($SuperG_class)&B_BaseExceptionG_methods;
         B_KeyboardInterruptG_methods.__init__ = (B_NoneType (*) (B_KeyboardInterrupt, B_str))B_BaseExceptionG_methods.__init__;
         B_KeyboardInterruptG_methods.__bool__ = (B_bool (*) (B_KeyboardInterrupt))B_valueG_methods.__bool__;
@@ -4842,7 +5050,9 @@ void B___init__ () {
         B_KeyboardInterruptG_methods.__deserialize__ = B_KeyboardInterruptD___deserialize__;
     }
     {
-        B_ExceptionG_methods.$GCINFO = "B_Exception";
+        memset(B_ExceptionD_gcbm, 0xFF, sizeof(B_ExceptionD_gcbm));
+        B_ExceptionG_methods.$GCdescr = GC_make_descriptor(B_ExceptionD_gcbm, GC_WORD_LEN(struct B_Exception));
+        B_ExceptionG_methods.$name = "B_Exception";
         B_ExceptionG_methods.$superclass = ($SuperG_class)&B_BaseExceptionG_methods;
         B_ExceptionG_methods.__init__ = (B_NoneType (*) (B_Exception, B_str))B_BaseExceptionG_methods.__init__;
         B_ExceptionG_methods.__bool__ = (B_bool (*) (B_Exception))B_valueG_methods.__bool__;
@@ -4852,7 +5062,9 @@ void B___init__ () {
         B_ExceptionG_methods.__deserialize__ = B_ExceptionD___deserialize__;
     }
     {
-        B_AssertionErrorG_methods.$GCINFO = "B_AssertionError";
+        memset(B_AssertionErrorD_gcbm, 0xFF, sizeof(B_AssertionErrorD_gcbm));
+        B_AssertionErrorG_methods.$GCdescr = GC_make_descriptor(B_AssertionErrorD_gcbm, GC_WORD_LEN(struct B_AssertionError));
+        B_AssertionErrorG_methods.$name = "B_AssertionError";
         B_AssertionErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods;
         B_AssertionErrorG_methods.__init__ = (B_NoneType (*) (B_AssertionError, B_str))B_BaseExceptionG_methods.__init__;
         B_AssertionErrorG_methods.__bool__ = (B_bool (*) (B_AssertionError))B_valueG_methods.__bool__;
@@ -4862,7 +5074,9 @@ void B___init__ () {
         B_AssertionErrorG_methods.__deserialize__ = B_AssertionErrorD___deserialize__;
     }
     {
-        B_LookupErrorG_methods.$GCINFO = "B_LookupError";
+        memset(B_LookupErrorD_gcbm, 0xFF, sizeof(B_LookupErrorD_gcbm));
+        B_LookupErrorG_methods.$GCdescr = GC_make_descriptor(B_LookupErrorD_gcbm, GC_WORD_LEN(struct B_LookupError));
+        B_LookupErrorG_methods.$name = "B_LookupError";
         B_LookupErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods;
         B_LookupErrorG_methods.__init__ = (B_NoneType (*) (B_LookupError, B_str))B_BaseExceptionG_methods.__init__;
         B_LookupErrorG_methods.__bool__ = (B_bool (*) (B_LookupError))B_valueG_methods.__bool__;
@@ -4872,7 +5086,9 @@ void B___init__ () {
         B_LookupErrorG_methods.__deserialize__ = B_LookupErrorD___deserialize__;
     }
     {
-        B_IndexErrorG_methods.$GCINFO = "B_IndexError";
+        memset(B_IndexErrorD_gcbm, 0xFF, sizeof(B_IndexErrorD_gcbm));
+        B_IndexErrorG_methods.$GCdescr = GC_make_descriptor(B_IndexErrorD_gcbm, GC_WORD_LEN(struct B_IndexError));
+        B_IndexErrorG_methods.$name = "B_IndexError";
         B_IndexErrorG_methods.$superclass = ($SuperG_class)&B_LookupErrorG_methods;
         B_IndexErrorG_methods.__init__ = (B_NoneType (*) (B_IndexError, B_str))B_BaseExceptionG_methods.__init__;
         B_IndexErrorG_methods.__bool__ = (B_bool (*) (B_IndexError))B_valueG_methods.__bool__;
@@ -4882,7 +5098,9 @@ void B___init__ () {
         B_IndexErrorG_methods.__deserialize__ = B_IndexErrorD___deserialize__;
     }
     {
-        B_KeyErrorG_methods.$GCINFO = "B_KeyError";
+        memset(B_KeyErrorD_gcbm, 0xFF, sizeof(B_KeyErrorD_gcbm));
+        B_KeyErrorG_methods.$GCdescr = GC_make_descriptor(B_KeyErrorD_gcbm, GC_WORD_LEN(struct B_KeyError));
+        B_KeyErrorG_methods.$name = "B_KeyError";
         B_KeyErrorG_methods.$superclass = ($SuperG_class)&B_LookupErrorG_methods;
         B_KeyErrorG_methods.__init__ = (B_NoneType (*) (B_KeyError, B_str))B_BaseExceptionG_methods.__init__;
         B_KeyErrorG_methods.__bool__ = (B_bool (*) (B_KeyError))B_valueG_methods.__bool__;
@@ -4892,7 +5110,9 @@ void B___init__ () {
         B_KeyErrorG_methods.__deserialize__ = B_KeyErrorD___deserialize__;
     }
     {
-        B_MemoryErrorG_methods.$GCINFO = "B_MemoryError";
+        memset(B_MemoryErrorD_gcbm, 0xFF, sizeof(B_MemoryErrorD_gcbm));
+        B_MemoryErrorG_methods.$GCdescr = GC_make_descriptor(B_MemoryErrorD_gcbm, GC_WORD_LEN(struct B_MemoryError));
+        B_MemoryErrorG_methods.$name = "B_MemoryError";
         B_MemoryErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods;
         B_MemoryErrorG_methods.__init__ = (B_NoneType (*) (B_MemoryError, B_str))B_BaseExceptionG_methods.__init__;
         B_MemoryErrorG_methods.__bool__ = (B_bool (*) (B_MemoryError))B_valueG_methods.__bool__;
@@ -4902,7 +5122,9 @@ void B___init__ () {
         B_MemoryErrorG_methods.__deserialize__ = B_MemoryErrorD___deserialize__;
     }
     {
-        B_OSErrorG_methods.$GCINFO = "B_OSError";
+        memset(B_OSErrorD_gcbm, 0xFF, sizeof(B_OSErrorD_gcbm));
+        B_OSErrorG_methods.$GCdescr = GC_make_descriptor(B_OSErrorD_gcbm, GC_WORD_LEN(struct B_OSError));
+        B_OSErrorG_methods.$name = "B_OSError";
         B_OSErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods;
         B_OSErrorG_methods.__init__ = (B_NoneType (*) (B_OSError, B_str))B_BaseExceptionG_methods.__init__;
         B_OSErrorG_methods.__bool__ = (B_bool (*) (B_OSError))B_valueG_methods.__bool__;
@@ -4912,7 +5134,9 @@ void B___init__ () {
         B_OSErrorG_methods.__deserialize__ = B_OSErrorD___deserialize__;
     }
     {
-        B_RuntimeErrorG_methods.$GCINFO = "B_RuntimeError";
+        memset(B_RuntimeErrorD_gcbm, 0xFF, sizeof(B_RuntimeErrorD_gcbm));
+        B_RuntimeErrorG_methods.$GCdescr = GC_make_descriptor(B_RuntimeErrorD_gcbm, GC_WORD_LEN(struct B_RuntimeError));
+        B_RuntimeErrorG_methods.$name = "B_RuntimeError";
         B_RuntimeErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods;
         B_RuntimeErrorG_methods.__init__ = (B_NoneType (*) (B_RuntimeError, B_str))B_BaseExceptionG_methods.__init__;
         B_RuntimeErrorG_methods.__bool__ = (B_bool (*) (B_RuntimeError))B_valueG_methods.__bool__;
@@ -4922,7 +5146,9 @@ void B___init__ () {
         B_RuntimeErrorG_methods.__deserialize__ = B_RuntimeErrorD___deserialize__;
     }
     {
-        B_NotImplementedErrorG_methods.$GCINFO = "B_NotImplementedError";
+        memset(B_NotImplementedErrorD_gcbm, 0xFF, sizeof(B_NotImplementedErrorD_gcbm));
+        B_NotImplementedErrorG_methods.$GCdescr = GC_make_descriptor(B_NotImplementedErrorD_gcbm, GC_WORD_LEN(struct B_NotImplementedError));
+        B_NotImplementedErrorG_methods.$name = "B_NotImplementedError";
         B_NotImplementedErrorG_methods.$superclass = ($SuperG_class)&B_RuntimeErrorG_methods;
         B_NotImplementedErrorG_methods.__init__ = (B_NoneType (*) (B_NotImplementedError, B_str))B_BaseExceptionG_methods.__init__;
         B_NotImplementedErrorG_methods.__bool__ = (B_bool (*) (B_NotImplementedError))B_valueG_methods.__bool__;
@@ -4932,7 +5158,9 @@ void B___init__ () {
         B_NotImplementedErrorG_methods.__deserialize__ = B_NotImplementedErrorD___deserialize__;
     }
     {
-        B_ValueErrorG_methods.$GCINFO = "B_ValueError";
+        memset(B_ValueErrorD_gcbm, 0xFF, sizeof(B_ValueErrorD_gcbm));
+        B_ValueErrorG_methods.$GCdescr = GC_make_descriptor(B_ValueErrorD_gcbm, GC_WORD_LEN(struct B_ValueError));
+        B_ValueErrorG_methods.$name = "B_ValueError";
         B_ValueErrorG_methods.$superclass = ($SuperG_class)&B_ExceptionG_methods;
         B_ValueErrorG_methods.__init__ = (B_NoneType (*) (B_ValueError, B_str))B_BaseExceptionG_methods.__init__;
         B_ValueErrorG_methods.__bool__ = (B_bool (*) (B_ValueError))B_valueG_methods.__bool__;
@@ -4942,7 +5170,9 @@ void B___init__ () {
         B_ValueErrorG_methods.__deserialize__ = B_ValueErrorD___deserialize__;
     }
     {
-        B_IdentityG_methods.$GCINFO = "B_Identity";
+        memset(B_IdentityD_gcbm, 0xFF, sizeof(B_IdentityD_gcbm));
+        B_IdentityG_methods.$GCdescr = GC_make_descriptor(B_IdentityD_gcbm, GC_WORD_LEN(struct B_Identity));
+        B_IdentityG_methods.$name = "B_Identity";
         B_IdentityG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_IdentityG_methods.__bool__ = (B_bool (*) (B_Identity))B_valueG_methods.__bool__;
         B_IdentityG_methods.__str__ = (B_str (*) (B_Identity))B_valueG_methods.__str__;
@@ -4953,7 +5183,9 @@ void B___init__ () {
         $register(&B_IdentityG_methods);
     }
     {
-        B_EqG_methods.$GCINFO = "B_Eq";
+        memset(B_EqD_gcbm, 0xFF, sizeof(B_EqD_gcbm));
+        B_EqG_methods.$GCdescr = GC_make_descriptor(B_EqD_gcbm, GC_WORD_LEN(struct B_Eq));
+        B_EqG_methods.$name = "B_Eq";
         B_EqG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_EqG_methods.__bool__ = (B_bool (*) (B_Eq))B_valueG_methods.__bool__;
         B_EqG_methods.__str__ = (B_str (*) (B_Eq))B_valueG_methods.__str__;
@@ -4965,7 +5197,9 @@ void B___init__ () {
         $register(&B_EqG_methods);
     }
     {
-        B_OrdG_methods.$GCINFO = "B_Ord";
+        memset(B_OrdD_gcbm, 0xFF, sizeof(B_OrdD_gcbm));
+        B_OrdG_methods.$GCdescr = GC_make_descriptor(B_OrdD_gcbm, GC_WORD_LEN(struct B_Ord));
+        B_OrdG_methods.$name = "B_Ord";
         B_OrdG_methods.$superclass = ($SuperG_class)&B_EqG_methods;
         B_OrdG_methods.__bool__ = (B_bool (*) (B_Ord))B_valueG_methods.__bool__;
         B_OrdG_methods.__str__ = (B_str (*) (B_Ord))B_valueG_methods.__str__;
@@ -4980,7 +5214,9 @@ void B___init__ () {
         $register(&B_OrdG_methods);
     }
     {
-        B_LogicalG_methods.$GCINFO = "B_Logical";
+        memset(B_LogicalD_gcbm, 0xFF, sizeof(B_LogicalD_gcbm));
+        B_LogicalG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_gcbm, GC_WORD_LEN(struct B_Logical));
+        B_LogicalG_methods.$name = "B_Logical";
         B_LogicalG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_LogicalG_methods.__bool__ = (B_bool (*) (B_Logical))B_valueG_methods.__bool__;
         B_LogicalG_methods.__str__ = (B_str (*) (B_Logical))B_valueG_methods.__str__;
@@ -4994,7 +5230,9 @@ void B___init__ () {
         $register(&B_LogicalG_methods);
     }
     {
-        B_PlusG_methods.$GCINFO = "B_Plus";
+        memset(B_PlusD_gcbm, 0xFF, sizeof(B_PlusD_gcbm));
+        B_PlusG_methods.$GCdescr = GC_make_descriptor(B_PlusD_gcbm, GC_WORD_LEN(struct B_Plus));
+        B_PlusG_methods.$name = "B_Plus";
         B_PlusG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_PlusG_methods.__bool__ = (B_bool (*) (B_Plus))B_valueG_methods.__bool__;
         B_PlusG_methods.__str__ = (B_str (*) (B_Plus))B_valueG_methods.__str__;
@@ -5006,7 +5244,9 @@ void B___init__ () {
         $register(&B_PlusG_methods);
     }
     {
-        B_MinusG_methods.$GCINFO = "B_Minus";
+        memset(B_MinusD_gcbm, 0xFF, sizeof(B_MinusD_gcbm));
+        B_MinusG_methods.$GCdescr = GC_make_descriptor(B_MinusD_gcbm, GC_WORD_LEN(struct B_Minus));
+        B_MinusG_methods.$name = "B_Minus";
         B_MinusG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_MinusG_methods.__bool__ = (B_bool (*) (B_Minus))B_valueG_methods.__bool__;
         B_MinusG_methods.__str__ = (B_str (*) (B_Minus))B_valueG_methods.__str__;
@@ -5018,7 +5258,9 @@ void B___init__ () {
         $register(&B_MinusG_methods);
     }
     {
-        B_TimesG_methods.$GCINFO = "B_Times";
+        memset(B_TimesD_gcbm, 0xFF, sizeof(B_TimesD_gcbm));
+        B_TimesG_methods.$GCdescr = GC_make_descriptor(B_TimesD_gcbm, GC_WORD_LEN(struct B_Times));
+        B_TimesG_methods.$name = "B_Times";
         B_TimesG_methods.$superclass = ($SuperG_class)&B_PlusG_methods;
         B_TimesG_methods.__bool__ = (B_bool (*) (B_Times))B_valueG_methods.__bool__;
         B_TimesG_methods.__str__ = (B_str (*) (B_Times))B_valueG_methods.__str__;
@@ -5031,7 +5273,9 @@ void B___init__ () {
         $register(&B_TimesG_methods);
     }
     {
-        B_DivG_methods.$GCINFO = "B_Div";
+        memset(B_DivD_gcbm, 0xFF, sizeof(B_DivD_gcbm));
+        B_DivG_methods.$GCdescr = GC_make_descriptor(B_DivD_gcbm, GC_WORD_LEN(struct B_Div));
+        B_DivG_methods.$name = "B_Div";
         B_DivG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_DivG_methods.__bool__ = (B_bool (*) (B_Div))B_valueG_methods.__bool__;
         B_DivG_methods.__str__ = (B_str (*) (B_Div))B_valueG_methods.__str__;
@@ -5043,7 +5287,9 @@ void B___init__ () {
         $register(&B_DivG_methods);
     }
     {
-        B_HashableG_methods.$GCINFO = "B_Hashable";
+        memset(B_HashableD_gcbm, 0xFF, sizeof(B_HashableD_gcbm));
+        B_HashableG_methods.$GCdescr = GC_make_descriptor(B_HashableD_gcbm, GC_WORD_LEN(struct B_Hashable));
+        B_HashableG_methods.$name = "B_Hashable";
         B_HashableG_methods.$superclass = ($SuperG_class)&B_EqG_methods;
         B_HashableG_methods.__bool__ = (B_bool (*) (B_Hashable))B_valueG_methods.__bool__;
         B_HashableG_methods.__str__ = (B_str (*) (B_Hashable))B_valueG_methods.__str__;
@@ -5055,7 +5301,9 @@ void B___init__ () {
         $register(&B_HashableG_methods);
     }
     {
-        B_complexG_methods.$GCINFO = "B_complex";
+        memset(B_complexD_gcbm, 0xFF, sizeof(B_complexD_gcbm));
+        B_complexG_methods.$GCdescr = GC_make_descriptor(B_complexD_gcbm, GC_WORD_LEN(struct B_complex));
+        B_complexG_methods.$name = "B_complex";
         B_complexG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_complexG_methods.__bool__ = (B_bool (*) (B_complex))B_valueG_methods.__bool__;
         B_complexG_methods.__str__ = B_complexD___str__;
@@ -5065,7 +5313,9 @@ void B___init__ () {
         B_complexG_methods.__deserialize__ = B_complexD___deserialize__;
     }
     {
-        B_dictG_methods.$GCINFO = "B_dict";
+        memset(B_dictD_gcbm, 0xFF, sizeof(B_dictD_gcbm));
+        B_dictG_methods.$GCdescr = GC_make_descriptor(B_dictD_gcbm, GC_WORD_LEN(struct B_dict));
+        B_dictG_methods.$name = "B_dict";
         B_dictG_methods.$superclass = ($SuperG_class)&B_objectG_methods;
         B_dictG_methods.__bool__ = (B_bool (*) (B_dict))B_valueG_methods.__bool__;
         B_dictG_methods.__str__ = B_dictD___str__;
@@ -5075,7 +5325,9 @@ void B___init__ () {
         B_dictG_methods.__deserialize__ = B_dictD___deserialize__;
     }
     {
-        B_setG_methods.$GCINFO = "B_set";
+        memset(B_setD_gcbm, 0xFF, sizeof(B_setD_gcbm));
+        B_setG_methods.$GCdescr = GC_make_descriptor(B_setD_gcbm, GC_WORD_LEN(struct B_set));
+        B_setG_methods.$name = "B_set";
         B_setG_methods.$superclass = ($SuperG_class)&B_objectG_methods;
         B_setG_methods.__bool__ = (B_bool (*) (B_set))B_valueG_methods.__bool__;
         B_setG_methods.__str__ = B_setD___str__;
@@ -5085,7 +5337,9 @@ void B___init__ () {
         B_setG_methods.__deserialize__ = B_setD___deserialize__;
     }
     {
-        B_NumberG_methods.$GCINFO = "B_Number";
+        memset(B_NumberD_gcbm, 0xFF, sizeof(B_NumberD_gcbm));
+        B_NumberG_methods.$GCdescr = GC_make_descriptor(B_NumberD_gcbm, GC_WORD_LEN(struct B_Number));
+        B_NumberG_methods.$name = "B_Number";
         B_NumberG_methods.$superclass = ($SuperG_class)&B_TimesG_methods;
         B_NumberG_methods.__bool__ = (B_bool (*) (B_Number))B_valueG_methods.__bool__;
         B_NumberG_methods.__str__ = (B_str (*) (B_Number))B_valueG_methods.__str__;
@@ -5099,7 +5353,9 @@ void B___init__ () {
         $register(&B_NumberG_methods);
     }
     {
-        B_MinusD_NumberG_methods.$GCINFO = "B_MinusD_Number";
+        memset(B_MinusD_NumberD_gcbm, 0xFF, sizeof(B_MinusD_NumberD_gcbm));
+        B_MinusD_NumberG_methods.$GCdescr = GC_make_descriptor(B_MinusD_NumberD_gcbm, GC_WORD_LEN(struct B_MinusD_Number));
+        B_MinusD_NumberG_methods.$name = "B_MinusD_Number";
         B_MinusD_NumberG_methods.$superclass = ($SuperG_class)&B_MinusG_methods;
         B_MinusD_NumberG_methods.__bool__ = (B_bool (*) (B_MinusD_Number))B_valueG_methods.__bool__;
         B_MinusD_NumberG_methods.__str__ = (B_str (*) (B_MinusD_Number))B_valueG_methods.__str__;
@@ -5111,7 +5367,9 @@ void B___init__ () {
         $register(&B_MinusD_NumberG_methods);
     }
     {
-        B_RealG_methods.$GCINFO = "B_Real";
+        memset(B_RealD_gcbm, 0xFF, sizeof(B_RealD_gcbm));
+        B_RealG_methods.$GCdescr = GC_make_descriptor(B_RealD_gcbm, GC_WORD_LEN(struct B_Real));
+        B_RealG_methods.$name = "B_Real";
         B_RealG_methods.$superclass = ($SuperG_class)&B_NumberG_methods;
         B_RealG_methods.__bool__ = (B_bool (*) (B_Real))B_valueG_methods.__bool__;
         B_RealG_methods.__str__ = (B_str (*) (B_Real))B_valueG_methods.__str__;
@@ -5125,7 +5383,9 @@ void B___init__ () {
         $register(&B_RealG_methods);
     }
     {
-        B_MinusD_RealG_methods.$GCINFO = "B_MinusD_Real";
+        memset(B_MinusD_RealD_gcbm, 0xFF, sizeof(B_MinusD_RealD_gcbm));
+        B_MinusD_RealG_methods.$GCdescr = GC_make_descriptor(B_MinusD_RealD_gcbm, GC_WORD_LEN(struct B_MinusD_Real));
+        B_MinusD_RealG_methods.$name = "B_MinusD_Real";
         B_MinusD_RealG_methods.$superclass = ($SuperG_class)&B_MinusD_NumberG_methods;
         B_MinusD_RealG_methods.__bool__ = (B_bool (*) (B_MinusD_Real))B_valueG_methods.__bool__;
         B_MinusD_RealG_methods.__str__ = (B_str (*) (B_MinusD_Real))B_valueG_methods.__str__;
@@ -5137,7 +5397,9 @@ void B___init__ () {
         $register(&B_MinusD_RealG_methods);
     }
     {
-        B_RealFloatG_methods.$GCINFO = "B_RealFloat";
+        memset(B_RealFloatD_gcbm, 0xFF, sizeof(B_RealFloatD_gcbm));
+        B_RealFloatG_methods.$GCdescr = GC_make_descriptor(B_RealFloatD_gcbm, GC_WORD_LEN(struct B_RealFloat));
+        B_RealFloatG_methods.$name = "B_RealFloat";
         B_RealFloatG_methods.$superclass = ($SuperG_class)&B_RealG_methods;
         B_RealFloatG_methods.__bool__ = (B_bool (*) (B_RealFloat))B_valueG_methods.__bool__;
         B_RealFloatG_methods.__str__ = (B_str (*) (B_RealFloat))B_valueG_methods.__str__;
@@ -5151,7 +5413,9 @@ void B___init__ () {
         $register(&B_RealFloatG_methods);
     }
     {
-        B_MinusD_RealFloatG_methods.$GCINFO = "B_MinusD_RealFloat";
+        memset(B_MinusD_RealFloatD_gcbm, 0xFF, sizeof(B_MinusD_RealFloatD_gcbm));
+        B_MinusD_RealFloatG_methods.$GCdescr = GC_make_descriptor(B_MinusD_RealFloatD_gcbm, GC_WORD_LEN(struct B_MinusD_RealFloat));
+        B_MinusD_RealFloatG_methods.$name = "B_MinusD_RealFloat";
         B_MinusD_RealFloatG_methods.$superclass = ($SuperG_class)&B_MinusD_RealG_methods;
         B_MinusD_RealFloatG_methods.__bool__ = (B_bool (*) (B_MinusD_RealFloat))B_valueG_methods.__bool__;
         B_MinusD_RealFloatG_methods.__str__ = (B_str (*) (B_MinusD_RealFloat))B_valueG_methods.__str__;
@@ -5163,7 +5427,9 @@ void B___init__ () {
         $register(&B_MinusD_RealFloatG_methods);
     }
     {
-        B_RationalG_methods.$GCINFO = "B_Rational";
+        memset(B_RationalD_gcbm, 0xFF, sizeof(B_RationalD_gcbm));
+        B_RationalG_methods.$GCdescr = GC_make_descriptor(B_RationalD_gcbm, GC_WORD_LEN(struct B_Rational));
+        B_RationalG_methods.$name = "B_Rational";
         B_RationalG_methods.$superclass = ($SuperG_class)&B_RealG_methods;
         B_RationalG_methods.__bool__ = (B_bool (*) (B_Rational))B_valueG_methods.__bool__;
         B_RationalG_methods.__str__ = (B_str (*) (B_Rational))B_valueG_methods.__str__;
@@ -5177,7 +5443,9 @@ void B___init__ () {
         $register(&B_RationalG_methods);
     }
     {
-        B_MinusD_RationalG_methods.$GCINFO = "B_MinusD_Rational";
+        memset(B_MinusD_RationalD_gcbm, 0xFF, sizeof(B_MinusD_RationalD_gcbm));
+        B_MinusD_RationalG_methods.$GCdescr = GC_make_descriptor(B_MinusD_RationalD_gcbm, GC_WORD_LEN(struct B_MinusD_Rational));
+        B_MinusD_RationalG_methods.$name = "B_MinusD_Rational";
         B_MinusD_RationalG_methods.$superclass = ($SuperG_class)&B_MinusD_RealG_methods;
         B_MinusD_RationalG_methods.__bool__ = (B_bool (*) (B_MinusD_Rational))B_valueG_methods.__bool__;
         B_MinusD_RationalG_methods.__str__ = (B_str (*) (B_MinusD_Rational))B_valueG_methods.__str__;
@@ -5189,7 +5457,9 @@ void B___init__ () {
         $register(&B_MinusD_RationalG_methods);
     }
     {
-        B_IntegralG_methods.$GCINFO = "B_Integral";
+        memset(B_IntegralD_gcbm, 0xFF, sizeof(B_IntegralD_gcbm));
+        B_IntegralG_methods.$GCdescr = GC_make_descriptor(B_IntegralD_gcbm, GC_WORD_LEN(struct B_Integral));
+        B_IntegralG_methods.$name = "B_Integral";
         B_IntegralG_methods.$superclass = ($SuperG_class)&B_RationalG_methods;
         B_IntegralG_methods.__bool__ = (B_bool (*) (B_Integral))B_valueG_methods.__bool__;
         B_IntegralG_methods.__str__ = (B_str (*) (B_Integral))B_valueG_methods.__str__;
@@ -5207,7 +5477,9 @@ void B___init__ () {
         $register(&B_IntegralG_methods);
     }
     {
-        B_MinusD_IntegralG_methods.$GCINFO = "B_MinusD_Integral";
+        memset(B_MinusD_IntegralD_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_gcbm));
+        B_MinusD_IntegralG_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_gcbm, GC_WORD_LEN(struct B_MinusD_Integral));
+        B_MinusD_IntegralG_methods.$name = "B_MinusD_Integral";
         B_MinusD_IntegralG_methods.$superclass = ($SuperG_class)&B_MinusD_RationalG_methods;
         B_MinusD_IntegralG_methods.__bool__ = (B_bool (*) (B_MinusD_Integral))B_valueG_methods.__bool__;
         B_MinusD_IntegralG_methods.__str__ = (B_str (*) (B_MinusD_Integral))B_valueG_methods.__str__;
@@ -5219,7 +5491,9 @@ void B___init__ () {
         $register(&B_MinusD_IntegralG_methods);
     }
     {
-        B_LogicalD_IntegralG_methods.$GCINFO = "B_LogicalD_Integral";
+        memset(B_LogicalD_IntegralD_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_gcbm));
+        B_LogicalD_IntegralG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_gcbm, GC_WORD_LEN(struct B_LogicalD_Integral));
+        B_LogicalD_IntegralG_methods.$name = "B_LogicalD_Integral";
         B_LogicalD_IntegralG_methods.$superclass = ($SuperG_class)&B_LogicalG_methods;
         B_LogicalD_IntegralG_methods.__bool__ = (B_bool (*) (B_LogicalD_Integral))B_valueG_methods.__bool__;
         B_LogicalD_IntegralG_methods.__str__ = (B_str (*) (B_LogicalD_Integral))B_valueG_methods.__str__;
@@ -5233,7 +5507,9 @@ void B___init__ () {
         $register(&B_LogicalD_IntegralG_methods);
     }
     {
-        B_HashableD_boolG_methods.$GCINFO = "B_HashableD_bool";
+        memset(B_HashableD_boolD_gcbm, 0xFF, sizeof(B_HashableD_boolD_gcbm));
+        B_HashableD_boolG_methods.$GCdescr = GC_make_descriptor(B_HashableD_boolD_gcbm, GC_WORD_LEN(struct B_HashableD_bool));
+        B_HashableD_boolG_methods.$name = "B_HashableD_bool";
         B_HashableD_boolG_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_boolG_methods.__bool__ = (B_bool (*) (B_HashableD_bool))B_valueG_methods.__bool__;
         B_HashableD_boolG_methods.__str__ = (B_str (*) (B_HashableD_bool))B_valueG_methods.__str__;
@@ -5247,7 +5523,9 @@ void B___init__ () {
         $register(&B_HashableD_boolG_methods);
     }
     {
-        B_IntegralD_intG_methods.$GCINFO = "B_IntegralD_int";
+        memset(B_IntegralD_intD_gcbm, 0xFF, sizeof(B_IntegralD_intD_gcbm));
+        B_IntegralD_intG_methods.$GCdescr = GC_make_descriptor(B_IntegralD_intD_gcbm, GC_WORD_LEN(struct B_IntegralD_int));
+        B_IntegralD_intG_methods.$name = "B_IntegralD_int";
         B_IntegralD_intG_methods.$superclass = ($SuperG_class)&B_IntegralG_methods;
         B_IntegralD_intG_methods.__bool__ = (B_bool (*) (B_IntegralD_int))B_valueG_methods.__bool__;
         B_IntegralD_intG_methods.__str__ = (B_str (*) (B_IntegralD_int))B_valueG_methods.__str__;
@@ -5291,7 +5569,9 @@ void B___init__ () {
         $register(&B_IntegralD_intG_methods);
     }
     {
-        B_MinusD_IntegralD_intG_methods.$GCINFO = "B_MinusD_IntegralD_int";
+        memset(B_MinusD_IntegralD_intD_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_intD_gcbm));
+        B_MinusD_IntegralD_intG_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_intD_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_int));
+        B_MinusD_IntegralD_intG_methods.$name = "B_MinusD_IntegralD_int";
         B_MinusD_IntegralD_intG_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods;
         B_MinusD_IntegralD_intG_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_int))B_valueG_methods.__bool__;
         B_MinusD_IntegralD_intG_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_int))B_valueG_methods.__str__;
@@ -5304,7 +5584,9 @@ void B___init__ () {
         $register(&B_MinusD_IntegralD_intG_methods);
     }
     {
-        B_LogicalD_IntegralD_intG_methods.$GCINFO = "B_LogicalD_IntegralD_int";
+        memset(B_LogicalD_IntegralD_intD_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_intD_gcbm));
+        B_LogicalD_IntegralD_intG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_intD_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_int));
+        B_LogicalD_IntegralD_intG_methods.$name = "B_LogicalD_IntegralD_int";
         B_LogicalD_IntegralD_intG_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods;
         B_LogicalD_IntegralD_intG_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_int))B_valueG_methods.__bool__;
         B_LogicalD_IntegralD_intG_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_int))B_valueG_methods.__str__;
@@ -5321,7 +5603,9 @@ void B___init__ () {
         $register(&B_LogicalD_IntegralD_intG_methods);
     }
     {
-        B_DivD_intG_methods.$GCINFO = "B_DivD_int";
+        memset(B_DivD_intD_gcbm, 0xFF, sizeof(B_DivD_intD_gcbm));
+        B_DivD_intG_methods.$GCdescr = GC_make_descriptor(B_DivD_intD_gcbm, GC_WORD_LEN(struct B_DivD_int));
+        B_DivD_intG_methods.$name = "B_DivD_int";
         B_DivD_intG_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_intG_methods.__bool__ = (B_bool (*) (B_DivD_int))B_valueG_methods.__bool__;
         B_DivD_intG_methods.__str__ = (B_str (*) (B_DivD_int))B_valueG_methods.__str__;
@@ -5334,7 +5618,9 @@ void B___init__ () {
         $register(&B_DivD_intG_methods);
     }
     {
-        B_OrdD_intG_methods.$GCINFO = "B_OrdD_int";
+        memset(B_OrdD_intD_gcbm, 0xFF, sizeof(B_OrdD_intD_gcbm));
+        B_OrdD_intG_methods.$GCdescr = GC_make_descriptor(B_OrdD_intD_gcbm, GC_WORD_LEN(struct B_OrdD_int));
+        B_OrdD_intG_methods.$name = "B_OrdD_int";
         B_OrdD_intG_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_intG_methods.__bool__ = (B_bool (*) (B_OrdD_int))B_valueG_methods.__bool__;
         B_OrdD_intG_methods.__str__ = (B_str (*) (B_OrdD_int))B_valueG_methods.__str__;
@@ -5351,7 +5637,9 @@ void B___init__ () {
         $register(&B_OrdD_intG_methods);
     }
     {
-        B_HashableD_intG_methods.$GCINFO = "B_HashableD_int";
+        memset(B_HashableD_intD_gcbm, 0xFF, sizeof(B_HashableD_intD_gcbm));
+        B_HashableD_intG_methods.$GCdescr = GC_make_descriptor(B_HashableD_intD_gcbm, GC_WORD_LEN(struct B_HashableD_int));
+        B_HashableD_intG_methods.$name = "B_HashableD_int";
         B_HashableD_intG_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_intG_methods.__bool__ = (B_bool (*) (B_HashableD_int))B_valueG_methods.__bool__;
         B_HashableD_intG_methods.__str__ = (B_str (*) (B_HashableD_int))B_valueG_methods.__str__;
@@ -5371,7 +5659,9 @@ void B___init__ () {
 
 
     {
-        B_IntegralD_i64G_methods.$GCINFO = "B_IntegralD_i64";
+        memset(B_IntegralD_i64D_gcbm, 0xFF, sizeof(B_IntegralD_i64D_gcbm));
+        B_IntegralD_i64G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_i64D_gcbm, GC_WORD_LEN(struct B_IntegralD_i64));
+        B_IntegralD_i64G_methods.$name = "B_IntegralD_i64";
         B_IntegralD_i64G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods;
         B_IntegralD_i64G_methods.__bool__ = (B_bool (*) (B_IntegralD_i64))B_valueG_methods.__bool__;
         B_IntegralD_i64G_methods.__str__ = (B_str (*) (B_IntegralD_i64))B_valueG_methods.__str__;
@@ -5415,7 +5705,9 @@ void B___init__ () {
         $register(&B_IntegralD_i64G_methods);
     }
     {
-        B_MinusD_IntegralD_i64G_methods.$GCINFO = "B_MinusD_IntegralD_i64";
+        memset(B_MinusD_IntegralD_i64D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_i64D_gcbm));
+        B_MinusD_IntegralD_i64G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_i64D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_i64));
+        B_MinusD_IntegralD_i64G_methods.$name = "B_MinusD_IntegralD_i64";
         B_MinusD_IntegralD_i64G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods;
         B_MinusD_IntegralD_i64G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_i64))B_valueG_methods.__bool__;
         B_MinusD_IntegralD_i64G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_i64))B_valueG_methods.__str__;
@@ -5428,7 +5720,9 @@ void B___init__ () {
         $register(&B_MinusD_IntegralD_i64G_methods);
     }
     {
-        B_LogicalD_IntegralD_i64G_methods.$GCINFO = "B_LogicalD_IntegralD_i64";
+        memset(B_LogicalD_IntegralD_i64D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_i64D_gcbm));
+        B_LogicalD_IntegralD_i64G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_i64D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_i64));
+        B_LogicalD_IntegralD_i64G_methods.$name = "B_LogicalD_IntegralD_i64";
         B_LogicalD_IntegralD_i64G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods;
         B_LogicalD_IntegralD_i64G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_i64))B_valueG_methods.__bool__;
         B_LogicalD_IntegralD_i64G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_i64))B_valueG_methods.__str__;
@@ -5445,7 +5739,9 @@ void B___init__ () {
         $register(&B_LogicalD_IntegralD_i64G_methods);
     }
     {
-        B_DivD_i64G_methods.$GCINFO = "B_DivD_i64";
+        memset(B_DivD_i64D_gcbm, 0xFF, sizeof(B_DivD_i64D_gcbm));
+        B_DivD_i64G_methods.$GCdescr = GC_make_descriptor(B_DivD_i64D_gcbm, GC_WORD_LEN(struct B_DivD_i64));
+        B_DivD_i64G_methods.$name = "B_DivD_i64";
         B_DivD_i64G_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_i64G_methods.__bool__ = (B_bool (*) (B_DivD_i64))B_valueG_methods.__bool__;
         B_DivD_i64G_methods.__str__ = (B_str (*) (B_DivD_i64))B_valueG_methods.__str__;
@@ -5458,7 +5754,9 @@ void B___init__ () {
         $register(&B_DivD_i64G_methods);
     }
     {
-        B_OrdD_i64G_methods.$GCINFO = "B_OrdD_i64";
+        memset(B_OrdD_i64D_gcbm, 0xFF, sizeof(B_OrdD_i64D_gcbm));
+        B_OrdD_i64G_methods.$GCdescr = GC_make_descriptor(B_OrdD_i64D_gcbm, GC_WORD_LEN(struct B_OrdD_i64));
+        B_OrdD_i64G_methods.$name = "B_OrdD_i64";
         B_OrdD_i64G_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_i64G_methods.__bool__ = (B_bool (*) (B_OrdD_i64))B_valueG_methods.__bool__;
         B_OrdD_i64G_methods.__str__ = (B_str (*) (B_OrdD_i64))B_valueG_methods.__str__;
@@ -5475,7 +5773,9 @@ void B___init__ () {
         $register(&B_OrdD_i64G_methods);
     }
     {
-        B_HashableD_i64G_methods.$GCINFO = "B_HashableD_i64";
+        memset(B_HashableD_i64D_gcbm, 0xFF, sizeof(B_HashableD_i64D_gcbm));
+        B_HashableD_i64G_methods.$GCdescr = GC_make_descriptor(B_HashableD_i64D_gcbm, GC_WORD_LEN(struct B_HashableD_i64));
+        B_HashableD_i64G_methods.$name = "B_HashableD_i64";
         B_HashableD_i64G_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_i64G_methods.__bool__ = (B_bool (*) (B_HashableD_i64))B_valueG_methods.__bool__;
         B_HashableD_i64G_methods.__str__ = (B_str (*) (B_HashableD_i64))B_valueG_methods.__str__;
@@ -5492,7 +5792,9 @@ void B___init__ () {
 
     
     {
-        B_IntegralD_i32G_methods.$GCINFO = "B_IntegralD_i32";
+        memset(B_IntegralD_i32D_gcbm, 0xFF, sizeof(B_IntegralD_i32D_gcbm));
+        B_IntegralD_i32G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_i32D_gcbm, GC_WORD_LEN(struct B_IntegralD_i32));
+        B_IntegralD_i32G_methods.$name = "B_IntegralD_i32";
         B_IntegralD_i32G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods;
         B_IntegralD_i32G_methods.__bool__ = (B_bool (*) (B_IntegralD_i32))B_valueG_methods.__bool__;
         B_IntegralD_i32G_methods.__str__ = (B_str (*) (B_IntegralD_i32))B_valueG_methods.__str__;
@@ -5536,7 +5838,9 @@ void B___init__ () {
         $register(&B_IntegralD_i32G_methods);
     }
     {
-        B_MinusD_IntegralD_i32G_methods.$GCINFO = "B_MinusD_IntegralD_i32";
+        memset(B_MinusD_IntegralD_i32D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_i32D_gcbm));
+        B_MinusD_IntegralD_i32G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_i32D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_i32));
+        B_MinusD_IntegralD_i32G_methods.$name = "B_MinusD_IntegralD_i32";
         B_MinusD_IntegralD_i32G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods;
         B_MinusD_IntegralD_i32G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_i32))B_valueG_methods.__bool__;
         B_MinusD_IntegralD_i32G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_i32))B_valueG_methods.__str__;
@@ -5549,7 +5853,9 @@ void B___init__ () {
         $register(&B_MinusD_IntegralD_i32G_methods);
     }
     {
-        B_LogicalD_IntegralD_i32G_methods.$GCINFO = "B_LogicalD_IntegralD_i32";
+        memset(B_LogicalD_IntegralD_i32D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_i32D_gcbm));
+        B_LogicalD_IntegralD_i32G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_i32D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_i32));
+        B_LogicalD_IntegralD_i32G_methods.$name = "B_LogicalD_IntegralD_i32";
         B_LogicalD_IntegralD_i32G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods;
         B_LogicalD_IntegralD_i32G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_i32))B_valueG_methods.__bool__;
         B_LogicalD_IntegralD_i32G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_i32))B_valueG_methods.__str__;
@@ -5566,7 +5872,9 @@ void B___init__ () {
         $register(&B_LogicalD_IntegralD_i32G_methods);
     }
     {
-        B_DivD_i32G_methods.$GCINFO = "B_DivD_i32";
+        memset(B_DivD_i32D_gcbm, 0xFF, sizeof(B_DivD_i32D_gcbm));
+        B_DivD_i32G_methods.$GCdescr = GC_make_descriptor(B_DivD_i32D_gcbm, GC_WORD_LEN(struct B_DivD_i32));
+        B_DivD_i32G_methods.$name = "B_DivD_i32";
         B_DivD_i32G_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_i32G_methods.__bool__ = (B_bool (*) (B_DivD_i32))B_valueG_methods.__bool__;
         B_DivD_i32G_methods.__str__ = (B_str (*) (B_DivD_i32))B_valueG_methods.__str__;
@@ -5579,7 +5887,9 @@ void B___init__ () {
         $register(&B_DivD_i32G_methods);
     }
     {
-        B_OrdD_i32G_methods.$GCINFO = "B_OrdD_i32";
+        memset(B_OrdD_i32D_gcbm, 0xFF, sizeof(B_OrdD_i32D_gcbm));
+        B_OrdD_i32G_methods.$GCdescr = GC_make_descriptor(B_OrdD_i32D_gcbm, GC_WORD_LEN(struct B_OrdD_i32));
+        B_OrdD_i32G_methods.$name = "B_OrdD_i32";
         B_OrdD_i32G_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_i32G_methods.__bool__ = (B_bool (*) (B_OrdD_i32))B_valueG_methods.__bool__;
         B_OrdD_i32G_methods.__str__ = (B_str (*) (B_OrdD_i32))B_valueG_methods.__str__;
@@ -5596,7 +5906,9 @@ void B___init__ () {
         $register(&B_OrdD_i32G_methods);
     }
     {
-        B_HashableD_i32G_methods.$GCINFO = "B_HashableD_i32";
+        memset(B_HashableD_i32D_gcbm, 0xFF, sizeof(B_HashableD_i32D_gcbm));
+        B_HashableD_i32G_methods.$GCdescr = GC_make_descriptor(B_HashableD_i32D_gcbm, GC_WORD_LEN(struct B_HashableD_i32));
+        B_HashableD_i32G_methods.$name = "B_HashableD_i32";
         B_HashableD_i32G_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_i32G_methods.__bool__ = (B_bool (*) (B_HashableD_i32))B_valueG_methods.__bool__;
         B_HashableD_i32G_methods.__str__ = (B_str (*) (B_HashableD_i32))B_valueG_methods.__str__;
@@ -5613,7 +5925,9 @@ void B___init__ () {
 
     
     {
-        B_IntegralD_i16G_methods.$GCINFO = "B_IntegralD_i16";
+        memset(B_IntegralD_i16D_gcbm, 0xFF, sizeof(B_IntegralD_i16D_gcbm));
+        B_IntegralD_i16G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_i16D_gcbm, GC_WORD_LEN(struct B_IntegralD_i16));
+        B_IntegralD_i16G_methods.$name = "B_IntegralD_i16";
         B_IntegralD_i16G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods;
         B_IntegralD_i16G_methods.__bool__ = (B_bool (*) (B_IntegralD_i16))B_valueG_methods.__bool__;
         B_IntegralD_i16G_methods.__str__ = (B_str (*) (B_IntegralD_i16))B_valueG_methods.__str__;
@@ -5657,7 +5971,9 @@ void B___init__ () {
         $register(&B_IntegralD_i16G_methods);
     }
     {
-        B_MinusD_IntegralD_i16G_methods.$GCINFO = "B_MinusD_IntegralD_i16";
+        memset(B_MinusD_IntegralD_i16D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_i16D_gcbm));
+        B_MinusD_IntegralD_i16G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_i16D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_i16));
+        B_MinusD_IntegralD_i16G_methods.$name = "B_MinusD_IntegralD_i16";
         B_MinusD_IntegralD_i16G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods;
         B_MinusD_IntegralD_i16G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_i16))B_valueG_methods.__bool__;
         B_MinusD_IntegralD_i16G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_i16))B_valueG_methods.__str__;
@@ -5670,7 +5986,9 @@ void B___init__ () {
         $register(&B_MinusD_IntegralD_i16G_methods);
     }
     {
-        B_LogicalD_IntegralD_i16G_methods.$GCINFO = "B_LogicalD_IntegralD_i16";
+        memset(B_LogicalD_IntegralD_i16D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_i16D_gcbm));
+        B_LogicalD_IntegralD_i16G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_i16D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_i16));
+        B_LogicalD_IntegralD_i16G_methods.$name = "B_LogicalD_IntegralD_i16";
         B_LogicalD_IntegralD_i16G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods;
         B_LogicalD_IntegralD_i16G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_i16))B_valueG_methods.__bool__;
         B_LogicalD_IntegralD_i16G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_i16))B_valueG_methods.__str__;
@@ -5687,7 +6005,9 @@ void B___init__ () {
         $register(&B_LogicalD_IntegralD_i16G_methods);
     }
     {
-        B_DivD_i16G_methods.$GCINFO = "B_DivD_i16";
+        memset(B_DivD_i16D_gcbm, 0xFF, sizeof(B_DivD_i16D_gcbm));
+        B_DivD_i16G_methods.$GCdescr = GC_make_descriptor(B_DivD_i16D_gcbm, GC_WORD_LEN(struct B_DivD_i16));
+        B_DivD_i16G_methods.$name = "B_DivD_i16";
         B_DivD_i16G_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_i16G_methods.__bool__ = (B_bool (*) (B_DivD_i16))B_valueG_methods.__bool__;
         B_DivD_i16G_methods.__str__ = (B_str (*) (B_DivD_i16))B_valueG_methods.__str__;
@@ -5700,7 +6020,9 @@ void B___init__ () {
         $register(&B_DivD_i16G_methods);
     }
     {
-        B_OrdD_i16G_methods.$GCINFO = "B_OrdD_i16";
+        memset(B_OrdD_i16D_gcbm, 0xFF, sizeof(B_OrdD_i16D_gcbm));
+        B_OrdD_i16G_methods.$GCdescr = GC_make_descriptor(B_OrdD_i16D_gcbm, GC_WORD_LEN(struct B_OrdD_i16));
+        B_OrdD_i16G_methods.$name = "B_OrdD_i16";
         B_OrdD_i16G_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_i16G_methods.__bool__ = (B_bool (*) (B_OrdD_i16))B_valueG_methods.__bool__;
         B_OrdD_i16G_methods.__str__ = (B_str (*) (B_OrdD_i16))B_valueG_methods.__str__;
@@ -5717,7 +6039,9 @@ void B___init__ () {
         $register(&B_OrdD_i16G_methods);
     }
     {
-        B_HashableD_i16G_methods.$GCINFO = "B_HashableD_i16";
+        memset(B_HashableD_i16D_gcbm, 0xFF, sizeof(B_HashableD_i16D_gcbm));
+        B_HashableD_i16G_methods.$GCdescr = GC_make_descriptor(B_HashableD_i16D_gcbm, GC_WORD_LEN(struct B_HashableD_i16));
+        B_HashableD_i16G_methods.$name = "B_HashableD_i16";
         B_HashableD_i16G_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_i16G_methods.__bool__ = (B_bool (*) (B_HashableD_i16))B_valueG_methods.__bool__;
         B_HashableD_i16G_methods.__str__ = (B_str (*) (B_HashableD_i16))B_valueG_methods.__str__;
@@ -5736,7 +6060,9 @@ void B___init__ () {
 
 
     {
-        B_IntegralD_u64G_methods.$GCINFO = "B_IntegralD_u64";
+        memset(B_IntegralD_u64D_gcbm, 0xFF, sizeof(B_IntegralD_u64D_gcbm));
+        B_IntegralD_u64G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_u64D_gcbm, GC_WORD_LEN(struct B_IntegralD_u64));
+        B_IntegralD_u64G_methods.$name = "B_IntegralD_u64";
         B_IntegralD_u64G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods;
         B_IntegralD_u64G_methods.__bool__ = (B_bool (*) (B_IntegralD_u64))B_valueG_methods.__bool__;
         B_IntegralD_u64G_methods.__str__ = (B_str (*) (B_IntegralD_u64))B_valueG_methods.__str__;
@@ -5780,7 +6106,9 @@ void B___init__ () {
         $register(&B_IntegralD_u64G_methods);
     }
     {
-        B_MinusD_IntegralD_u64G_methods.$GCINFO = "B_MinusD_IntegralD_u64";
+        memset(B_MinusD_IntegralD_u64D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_u64D_gcbm));
+        B_MinusD_IntegralD_u64G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_u64D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_u64));
+        B_MinusD_IntegralD_u64G_methods.$name = "B_MinusD_IntegralD_u64";
         B_MinusD_IntegralD_u64G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods;
         B_MinusD_IntegralD_u64G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_u64))B_valueG_methods.__bool__;
         B_MinusD_IntegralD_u64G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_u64))B_valueG_methods.__str__;
@@ -5793,7 +6121,9 @@ void B___init__ () {
         $register(&B_MinusD_IntegralD_u64G_methods);
     }
     {
-        B_LogicalD_IntegralD_u64G_methods.$GCINFO = "B_LogicalD_IntegralD_u64";
+        memset(B_LogicalD_IntegralD_u64D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_u64D_gcbm));
+        B_LogicalD_IntegralD_u64G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_u64D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_u64));
+        B_LogicalD_IntegralD_u64G_methods.$name = "B_LogicalD_IntegralD_u64";
         B_LogicalD_IntegralD_u64G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods;
         B_LogicalD_IntegralD_u64G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_u64))B_valueG_methods.__bool__;
         B_LogicalD_IntegralD_u64G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_u64))B_valueG_methods.__str__;
@@ -5810,7 +6140,9 @@ void B___init__ () {
         $register(&B_LogicalD_IntegralD_u64G_methods);
     }
     {
-        B_DivD_u64G_methods.$GCINFO = "B_DivD_u64";
+        memset(B_DivD_u64D_gcbm, 0xFF, sizeof(B_DivD_u64D_gcbm));
+        B_DivD_u64G_methods.$GCdescr = GC_make_descriptor(B_DivD_u64D_gcbm, GC_WORD_LEN(struct B_DivD_u64));
+        B_DivD_u64G_methods.$name = "B_DivD_u64";
         B_DivD_u64G_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_u64G_methods.__bool__ = (B_bool (*) (B_DivD_u64))B_valueG_methods.__bool__;
         B_DivD_u64G_methods.__str__ = (B_str (*) (B_DivD_u64))B_valueG_methods.__str__;
@@ -5823,7 +6155,9 @@ void B___init__ () {
         $register(&B_DivD_u64G_methods);
     }
     {
-        B_OrdD_u64G_methods.$GCINFO = "B_OrdD_u64";
+        memset(B_OrdD_u64D_gcbm, 0xFF, sizeof(B_OrdD_u64D_gcbm));
+        B_OrdD_u64G_methods.$GCdescr = GC_make_descriptor(B_OrdD_u64D_gcbm, GC_WORD_LEN(struct B_OrdD_u64));
+        B_OrdD_u64G_methods.$name = "B_OrdD_u64";
         B_OrdD_u64G_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_u64G_methods.__bool__ = (B_bool (*) (B_OrdD_u64))B_valueG_methods.__bool__;
         B_OrdD_u64G_methods.__str__ = (B_str (*) (B_OrdD_u64))B_valueG_methods.__str__;
@@ -5840,7 +6174,9 @@ void B___init__ () {
         $register(&B_OrdD_u64G_methods);
     }
     {
-        B_HashableD_u64G_methods.$GCINFO = "B_HashableD_u64";
+        memset(B_HashableD_u64D_gcbm, 0xFF, sizeof(B_HashableD_u64D_gcbm));
+        B_HashableD_u64G_methods.$GCdescr = GC_make_descriptor(B_HashableD_u64D_gcbm, GC_WORD_LEN(struct B_HashableD_u64));
+        B_HashableD_u64G_methods.$name = "B_HashableD_u64";
         B_HashableD_u64G_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_u64G_methods.__bool__ = (B_bool (*) (B_HashableD_u64))B_valueG_methods.__bool__;
         B_HashableD_u64G_methods.__str__ = (B_str (*) (B_HashableD_u64))B_valueG_methods.__str__;
@@ -5860,7 +6196,9 @@ void B___init__ () {
 
 
     {
-        B_IntegralD_u32G_methods.$GCINFO = "B_IntegralD_u32";
+        memset(B_IntegralD_u32D_gcbm, 0xFF, sizeof(B_IntegralD_u32D_gcbm));
+        B_IntegralD_u32G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_u32D_gcbm, GC_WORD_LEN(struct B_IntegralD_u32));
+        B_IntegralD_u32G_methods.$name = "B_IntegralD_u32";
         B_IntegralD_u32G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods;
         B_IntegralD_u32G_methods.__bool__ = (B_bool (*) (B_IntegralD_u32))B_valueG_methods.__bool__;
         B_IntegralD_u32G_methods.__str__ = (B_str (*) (B_IntegralD_u32))B_valueG_methods.__str__;
@@ -5904,7 +6242,9 @@ void B___init__ () {
         $register(&B_IntegralD_u32G_methods);
     }
     {
-        B_MinusD_IntegralD_u32G_methods.$GCINFO = "B_MinusD_IntegralD_u32";
+        memset(B_MinusD_IntegralD_u32D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_u32D_gcbm));
+        B_MinusD_IntegralD_u32G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_u32D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_u32));
+        B_MinusD_IntegralD_u32G_methods.$name = "B_MinusD_IntegralD_u32";
         B_MinusD_IntegralD_u32G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods;
         B_MinusD_IntegralD_u32G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_u32))B_valueG_methods.__bool__;
         B_MinusD_IntegralD_u32G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_u32))B_valueG_methods.__str__;
@@ -5917,7 +6257,9 @@ void B___init__ () {
         $register(&B_MinusD_IntegralD_u32G_methods);
     }
     {
-        B_LogicalD_IntegralD_u32G_methods.$GCINFO = "B_LogicalD_IntegralD_u32";
+        memset(B_LogicalD_IntegralD_u32D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_u32D_gcbm));
+        B_LogicalD_IntegralD_u32G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_u32D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_u32));
+        B_LogicalD_IntegralD_u32G_methods.$name = "B_LogicalD_IntegralD_u32";
         B_LogicalD_IntegralD_u32G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods;
         B_LogicalD_IntegralD_u32G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_u32))B_valueG_methods.__bool__;
         B_LogicalD_IntegralD_u32G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_u32))B_valueG_methods.__str__;
@@ -5934,7 +6276,9 @@ void B___init__ () {
         $register(&B_LogicalD_IntegralD_u32G_methods);
     }
     {
-        B_DivD_u32G_methods.$GCINFO = "B_DivD_u32";
+        memset(B_DivD_u32D_gcbm, 0xFF, sizeof(B_DivD_u32D_gcbm));
+        B_DivD_u32G_methods.$GCdescr = GC_make_descriptor(B_DivD_u32D_gcbm, GC_WORD_LEN(struct B_DivD_u32));
+        B_DivD_u32G_methods.$name = "B_DivD_u32";
         B_DivD_u32G_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_u32G_methods.__bool__ = (B_bool (*) (B_DivD_u32))B_valueG_methods.__bool__;
         B_DivD_u32G_methods.__str__ = (B_str (*) (B_DivD_u32))B_valueG_methods.__str__;
@@ -5947,7 +6291,9 @@ void B___init__ () {
         $register(&B_DivD_u32G_methods);
     }
     {
-        B_OrdD_u32G_methods.$GCINFO = "B_OrdD_u32";
+        memset(B_OrdD_u32D_gcbm, 0xFF, sizeof(B_OrdD_u32D_gcbm));
+        B_OrdD_u32G_methods.$GCdescr = GC_make_descriptor(B_OrdD_u32D_gcbm, GC_WORD_LEN(struct B_OrdD_u32));
+        B_OrdD_u32G_methods.$name = "B_OrdD_u32";
         B_OrdD_u32G_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_u32G_methods.__bool__ = (B_bool (*) (B_OrdD_u32))B_valueG_methods.__bool__;
         B_OrdD_u32G_methods.__str__ = (B_str (*) (B_OrdD_u32))B_valueG_methods.__str__;
@@ -5964,7 +6310,9 @@ void B___init__ () {
         $register(&B_OrdD_u32G_methods);
     }
     {
-        B_HashableD_u32G_methods.$GCINFO = "B_HashableD_u32";
+        memset(B_HashableD_u32D_gcbm, 0xFF, sizeof(B_HashableD_u32D_gcbm));
+        B_HashableD_u32G_methods.$GCdescr = GC_make_descriptor(B_HashableD_u32D_gcbm, GC_WORD_LEN(struct B_HashableD_u32));
+        B_HashableD_u32G_methods.$name = "B_HashableD_u32";
         B_HashableD_u32G_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_u32G_methods.__bool__ = (B_bool (*) (B_HashableD_u32))B_valueG_methods.__bool__;
         B_HashableD_u32G_methods.__str__ = (B_str (*) (B_HashableD_u32))B_valueG_methods.__str__;
@@ -5984,7 +6332,9 @@ void B___init__ () {
 
 
     {
-        B_IntegralD_u16G_methods.$GCINFO = "B_IntegralD_u16";
+        memset(B_IntegralD_u16D_gcbm, 0xFF, sizeof(B_IntegralD_u16D_gcbm));
+        B_IntegralD_u16G_methods.$GCdescr = GC_make_descriptor(B_IntegralD_u16D_gcbm, GC_WORD_LEN(struct B_IntegralD_u16));
+        B_IntegralD_u16G_methods.$name = "B_IntegralD_u16";
         B_IntegralD_u16G_methods.$superclass = ($SuperG_class)&B_IntegralG_methods;
         B_IntegralD_u16G_methods.__bool__ = (B_bool (*) (B_IntegralD_u16))B_valueG_methods.__bool__;
         B_IntegralD_u16G_methods.__str__ = (B_str (*) (B_IntegralD_u16))B_valueG_methods.__str__;
@@ -6028,7 +6378,9 @@ void B___init__ () {
         $register(&B_IntegralD_u16G_methods);
     }
     {
-        B_MinusD_IntegralD_u16G_methods.$GCINFO = "B_MinusD_IntegralD_u16";
+        memset(B_MinusD_IntegralD_u16D_gcbm, 0xFF, sizeof(B_MinusD_IntegralD_u16D_gcbm));
+        B_MinusD_IntegralD_u16G_methods.$GCdescr = GC_make_descriptor(B_MinusD_IntegralD_u16D_gcbm, GC_WORD_LEN(struct B_MinusD_IntegralD_u16));
+        B_MinusD_IntegralD_u16G_methods.$name = "B_MinusD_IntegralD_u16";
         B_MinusD_IntegralD_u16G_methods.$superclass = ($SuperG_class)&B_MinusD_IntegralG_methods;
         B_MinusD_IntegralD_u16G_methods.__bool__ = (B_bool (*) (B_MinusD_IntegralD_u16))B_valueG_methods.__bool__;
         B_MinusD_IntegralD_u16G_methods.__str__ = (B_str (*) (B_MinusD_IntegralD_u16))B_valueG_methods.__str__;
@@ -6041,7 +6393,9 @@ void B___init__ () {
         $register(&B_MinusD_IntegralD_u16G_methods);
     }
     {
-        B_LogicalD_IntegralD_u16G_methods.$GCINFO = "B_LogicalD_IntegralD_u16";
+        memset(B_LogicalD_IntegralD_u16D_gcbm, 0xFF, sizeof(B_LogicalD_IntegralD_u16D_gcbm));
+        B_LogicalD_IntegralD_u16G_methods.$GCdescr = GC_make_descriptor(B_LogicalD_IntegralD_u16D_gcbm, GC_WORD_LEN(struct B_LogicalD_IntegralD_u16));
+        B_LogicalD_IntegralD_u16G_methods.$name = "B_LogicalD_IntegralD_u16";
         B_LogicalD_IntegralD_u16G_methods.$superclass = ($SuperG_class)&B_LogicalD_IntegralG_methods;
         B_LogicalD_IntegralD_u16G_methods.__bool__ = (B_bool (*) (B_LogicalD_IntegralD_u16))B_valueG_methods.__bool__;
         B_LogicalD_IntegralD_u16G_methods.__str__ = (B_str (*) (B_LogicalD_IntegralD_u16))B_valueG_methods.__str__;
@@ -6058,7 +6412,9 @@ void B___init__ () {
         $register(&B_LogicalD_IntegralD_u16G_methods);
     }
     {
-        B_DivD_u16G_methods.$GCINFO = "B_DivD_u16";
+        memset(B_DivD_u16D_gcbm, 0xFF, sizeof(B_DivD_u16D_gcbm));
+        B_DivD_u16G_methods.$GCdescr = GC_make_descriptor(B_DivD_u16D_gcbm, GC_WORD_LEN(struct B_DivD_u16));
+        B_DivD_u16G_methods.$name = "B_DivD_u16";
         B_DivD_u16G_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_u16G_methods.__bool__ = (B_bool (*) (B_DivD_u16))B_valueG_methods.__bool__;
         B_DivD_u16G_methods.__str__ = (B_str (*) (B_DivD_u16))B_valueG_methods.__str__;
@@ -6071,7 +6427,9 @@ void B___init__ () {
         $register(&B_DivD_u16G_methods);
     }
     {
-        B_OrdD_u16G_methods.$GCINFO = "B_OrdD_u16";
+        memset(B_OrdD_u16D_gcbm, 0xFF, sizeof(B_OrdD_u16D_gcbm));
+        B_OrdD_u16G_methods.$GCdescr = GC_make_descriptor(B_OrdD_u16D_gcbm, GC_WORD_LEN(struct B_OrdD_u16));
+        B_OrdD_u16G_methods.$name = "B_OrdD_u16";
         B_OrdD_u16G_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_u16G_methods.__bool__ = (B_bool (*) (B_OrdD_u16))B_valueG_methods.__bool__;
         B_OrdD_u16G_methods.__str__ = (B_str (*) (B_OrdD_u16))B_valueG_methods.__str__;
@@ -6088,7 +6446,9 @@ void B___init__ () {
         $register(&B_OrdD_u16G_methods);
     }
     {
-        B_HashableD_u16G_methods.$GCINFO = "B_HashableD_u16";
+        memset(B_HashableD_u16D_gcbm, 0xFF, sizeof(B_HashableD_u16D_gcbm));
+        B_HashableD_u16G_methods.$GCdescr = GC_make_descriptor(B_HashableD_u16D_gcbm, GC_WORD_LEN(struct B_HashableD_u16));
+        B_HashableD_u16G_methods.$name = "B_HashableD_u16";
         B_HashableD_u16G_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_u16G_methods.__bool__ = (B_bool (*) (B_HashableD_u16))B_valueG_methods.__bool__;
         B_HashableD_u16G_methods.__str__ = (B_str (*) (B_HashableD_u16))B_valueG_methods.__str__;
@@ -6107,7 +6467,9 @@ void B___init__ () {
 
 
     {
-        B_RealFloatD_floatG_methods.$GCINFO = "B_RealFloatD_float";
+        memset(B_RealFloatD_floatD_gcbm, 0xFF, sizeof(B_RealFloatD_floatD_gcbm));
+        B_RealFloatD_floatG_methods.$GCdescr = GC_make_descriptor(B_RealFloatD_floatD_gcbm, GC_WORD_LEN(struct B_RealFloatD_float));
+        B_RealFloatD_floatG_methods.$name = "B_RealFloatD_float";
         B_RealFloatD_floatG_methods.$superclass = ($SuperG_class)&B_RealFloatG_methods;
         B_RealFloatD_floatG_methods.__bool__ = (B_bool (*) (B_RealFloatD_float))B_valueG_methods.__bool__;
         B_RealFloatD_floatG_methods.__str__ = (B_str (*) (B_RealFloatD_float))B_valueG_methods.__str__;
@@ -6137,7 +6499,9 @@ void B___init__ () {
         $register(&B_RealFloatD_floatG_methods);
     }
     {
-        B_MinusD_RealFloatD_floatG_methods.$GCINFO = "B_MinusD_RealFloatD_float";
+        memset(B_MinusD_RealFloatD_floatD_gcbm, 0xFF, sizeof(B_MinusD_RealFloatD_floatD_gcbm));
+        B_MinusD_RealFloatD_floatG_methods.$GCdescr = GC_make_descriptor(B_MinusD_RealFloatD_floatD_gcbm, GC_WORD_LEN(struct B_MinusD_RealFloatD_float));
+        B_MinusD_RealFloatD_floatG_methods.$name = "B_MinusD_RealFloatD_float";
         B_MinusD_RealFloatD_floatG_methods.$superclass = ($SuperG_class)&B_MinusD_RealFloatG_methods;
         B_MinusD_RealFloatD_floatG_methods.__bool__ = (B_bool (*) (B_MinusD_RealFloatD_float))B_valueG_methods.__bool__;
         B_MinusD_RealFloatD_floatG_methods.__str__ = (B_str (*) (B_MinusD_RealFloatD_float))B_valueG_methods.__str__;
@@ -6150,7 +6514,9 @@ void B___init__ () {
         $register(&B_MinusD_RealFloatD_floatG_methods);
     }
     {
-        B_DivD_floatG_methods.$GCINFO = "B_DivD_float";
+        memset(B_DivD_floatD_gcbm, 0xFF, sizeof(B_DivD_floatD_gcbm));
+        B_DivD_floatG_methods.$GCdescr = GC_make_descriptor(B_DivD_floatD_gcbm, GC_WORD_LEN(struct B_DivD_float));
+        B_DivD_floatG_methods.$name = "B_DivD_float";
         B_DivD_floatG_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_floatG_methods.__bool__ = (B_bool (*) (B_DivD_float))B_valueG_methods.__bool__;
         B_DivD_floatG_methods.__str__ = (B_str (*) (B_DivD_float))B_valueG_methods.__str__;
@@ -6163,7 +6529,9 @@ void B___init__ () {
         $register(&B_DivD_floatG_methods);
     }
     {
-        B_OrdD_floatG_methods.$GCINFO = "B_OrdD_float";
+        memset(B_OrdD_floatD_gcbm, 0xFF, sizeof(B_OrdD_floatD_gcbm));
+        B_OrdD_floatG_methods.$GCdescr = GC_make_descriptor(B_OrdD_floatD_gcbm, GC_WORD_LEN(struct B_OrdD_float));
+        B_OrdD_floatG_methods.$name = "B_OrdD_float";
         B_OrdD_floatG_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_floatG_methods.__bool__ = (B_bool (*) (B_OrdD_float))B_valueG_methods.__bool__;
         B_OrdD_floatG_methods.__str__ = (B_str (*) (B_OrdD_float))B_valueG_methods.__str__;
@@ -6180,7 +6548,9 @@ void B___init__ () {
         $register(&B_OrdD_floatG_methods);
     }
     {
-        B_HashableD_floatG_methods.$GCINFO = "B_HashableD_float";
+        memset(B_HashableD_floatD_gcbm, 0xFF, sizeof(B_HashableD_floatD_gcbm));
+        B_HashableD_floatG_methods.$GCdescr = GC_make_descriptor(B_HashableD_floatD_gcbm, GC_WORD_LEN(struct B_HashableD_float));
+        B_HashableD_floatG_methods.$name = "B_HashableD_float";
         B_HashableD_floatG_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_floatG_methods.__bool__ = (B_bool (*) (B_HashableD_float))B_valueG_methods.__bool__;
         B_HashableD_floatG_methods.__str__ = (B_str (*) (B_HashableD_float))B_valueG_methods.__str__;
@@ -6193,7 +6563,9 @@ void B___init__ () {
         $register(&B_HashableD_floatG_methods);
     }
     {
-        B_NumberD_complexG_methods.$GCINFO = "B_NumberD_complex";
+        memset(B_NumberD_complexD_gcbm, 0xFF, sizeof(B_NumberD_complexD_gcbm));
+        B_NumberD_complexG_methods.$GCdescr = GC_make_descriptor(B_NumberD_complexD_gcbm, GC_WORD_LEN(struct B_NumberD_complex));
+        B_NumberD_complexG_methods.$name = "B_NumberD_complex";
         B_NumberD_complexG_methods.$superclass = ($SuperG_class)&B_NumberG_methods;
         B_NumberD_complexG_methods.__bool__ = (B_bool (*) (B_NumberD_complex))B_valueG_methods.__bool__;
         B_NumberD_complexG_methods.__str__ = (B_str (*) (B_NumberD_complex))B_valueG_methods.__str__;
@@ -6218,7 +6590,9 @@ void B___init__ () {
         $register(&B_NumberD_complexG_methods);
     }
     {
-        B_MinusD_NumberD_complexG_methods.$GCINFO = "B_MinusD_NumberD_complex";
+        memset(B_MinusD_NumberD_complexD_gcbm, 0xFF, sizeof(B_MinusD_NumberD_complexD_gcbm));
+        B_MinusD_NumberD_complexG_methods.$GCdescr = GC_make_descriptor(B_MinusD_NumberD_complexD_gcbm, GC_WORD_LEN(struct B_MinusD_NumberD_complex));
+        B_MinusD_NumberD_complexG_methods.$name = "B_MinusD_NumberD_complex";
         B_MinusD_NumberD_complexG_methods.$superclass = ($SuperG_class)&B_MinusD_NumberG_methods;
         B_MinusD_NumberD_complexG_methods.__bool__ = (B_bool (*) (B_MinusD_NumberD_complex))B_valueG_methods.__bool__;
         B_MinusD_NumberD_complexG_methods.__str__ = (B_str (*) (B_MinusD_NumberD_complex))B_valueG_methods.__str__;
@@ -6231,7 +6605,9 @@ void B___init__ () {
         $register(&B_MinusD_NumberD_complexG_methods);
     }
     {
-        B_DivD_complexG_methods.$GCINFO = "B_DivD_complex";
+        memset(B_DivD_complexD_gcbm, 0xFF, sizeof(B_DivD_complexD_gcbm));
+        B_DivD_complexG_methods.$GCdescr = GC_make_descriptor(B_DivD_complexD_gcbm, GC_WORD_LEN(struct B_DivD_complex));
+        B_DivD_complexG_methods.$name = "B_DivD_complex";
         B_DivD_complexG_methods.$superclass = ($SuperG_class)&B_DivG_methods;
         B_DivD_complexG_methods.__bool__ = (B_bool (*) (B_DivD_complex))B_valueG_methods.__bool__;
         B_DivD_complexG_methods.__str__ = (B_str (*) (B_DivD_complex))B_valueG_methods.__str__;
@@ -6244,7 +6620,9 @@ void B___init__ () {
         $register(&B_DivD_complexG_methods);
     }
     {
-        B_EqD_complexG_methods.$GCINFO = "B_EqD_complex";
+        memset(B_EqD_complexD_gcbm, 0xFF, sizeof(B_EqD_complexD_gcbm));
+        B_EqD_complexG_methods.$GCdescr = GC_make_descriptor(B_EqD_complexD_gcbm, GC_WORD_LEN(struct B_EqD_complex));
+        B_EqD_complexG_methods.$name = "B_EqD_complex";
         B_EqD_complexG_methods.$superclass = ($SuperG_class)&B_EqG_methods;
         B_EqD_complexG_methods.__bool__ = (B_bool (*) (B_EqD_complex))B_valueG_methods.__bool__;
         B_EqD_complexG_methods.__str__ = (B_str (*) (B_EqD_complex))B_valueG_methods.__str__;
@@ -6257,7 +6635,9 @@ void B___init__ () {
         $register(&B_EqD_complexG_methods);
     }
     {
-        B_HashableD_complexG_methods.$GCINFO = "B_HashableD_complex";
+        memset(B_HashableD_complexD_gcbm, 0xFF, sizeof(B_HashableD_complexD_gcbm));
+        B_HashableD_complexG_methods.$GCdescr = GC_make_descriptor(B_HashableD_complexD_gcbm, GC_WORD_LEN(struct B_HashableD_complex));
+        B_HashableD_complexG_methods.$name = "B_HashableD_complex";
         B_HashableD_complexG_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_complexG_methods.__bool__ = (B_bool (*) (B_HashableD_complex))B_valueG_methods.__bool__;
         B_HashableD_complexG_methods.__str__ = (B_str (*) (B_HashableD_complex))B_valueG_methods.__str__;
@@ -6270,7 +6650,9 @@ void B___init__ () {
         $register(&B_HashableD_complexG_methods);
     }
     {
-        B_IndexedG_methods.$GCINFO = "B_Indexed";
+        memset(B_IndexedD_gcbm, 0xFF, sizeof(B_IndexedD_gcbm));
+        B_IndexedG_methods.$GCdescr = GC_make_descriptor(B_IndexedD_gcbm, GC_WORD_LEN(struct B_Indexed));
+        B_IndexedG_methods.$name = "B_Indexed";
         B_IndexedG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_IndexedG_methods.__bool__ = (B_bool (*) (B_Indexed))B_valueG_methods.__bool__;
         B_IndexedG_methods.__str__ = (B_str (*) (B_Indexed))B_valueG_methods.__str__;
@@ -6281,7 +6663,9 @@ void B___init__ () {
         $register(&B_IndexedG_methods);
     }
     {
-        B_SliceableG_methods.$GCINFO = "B_Sliceable";
+        memset(B_SliceableD_gcbm, 0xFF, sizeof(B_SliceableD_gcbm));
+        B_SliceableG_methods.$GCdescr = GC_make_descriptor(B_SliceableD_gcbm, GC_WORD_LEN(struct B_Sliceable));
+        B_SliceableG_methods.$name = "B_Sliceable";
         B_SliceableG_methods.$superclass = ($SuperG_class)&B_IndexedG_methods;
         B_SliceableG_methods.__bool__ = (B_bool (*) (B_Sliceable))B_valueG_methods.__bool__;
         B_SliceableG_methods.__str__ = (B_str (*) (B_Sliceable))B_valueG_methods.__str__;
@@ -6292,7 +6676,9 @@ void B___init__ () {
         $register(&B_SliceableG_methods);
     }
     {
-        B_CollectionG_methods.$GCINFO = "B_Collection";
+        memset(B_CollectionD_gcbm, 0xFF, sizeof(B_CollectionD_gcbm));
+        B_CollectionG_methods.$GCdescr = GC_make_descriptor(B_CollectionD_gcbm, GC_WORD_LEN(struct B_Collection));
+        B_CollectionG_methods.$name = "B_Collection";
         B_CollectionG_methods.$superclass = ($SuperG_class)&B_IterableG_methods;
         B_CollectionG_methods.__bool__ = (B_bool (*) (B_Collection))B_valueG_methods.__bool__;
         B_CollectionG_methods.__str__ = (B_str (*) (B_Collection))B_valueG_methods.__str__;
@@ -6303,7 +6689,9 @@ void B___init__ () {
         $register(&B_CollectionG_methods);
     }
     {
-        B_ContainerG_methods.$GCINFO = "B_Container";
+        memset(B_ContainerD_gcbm, 0xFF, sizeof(B_ContainerD_gcbm));
+        B_ContainerG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_gcbm, GC_WORD_LEN(struct B_Container));
+        B_ContainerG_methods.$name = "B_Container";
         B_ContainerG_methods.$superclass = ($SuperG_class)&B_CollectionG_methods;
         B_ContainerG_methods.__bool__ = (B_bool (*) (B_Container))B_valueG_methods.__bool__;
         B_ContainerG_methods.__str__ = (B_str (*) (B_Container))B_valueG_methods.__str__;
@@ -6314,7 +6702,9 @@ void B___init__ () {
         $register(&B_ContainerG_methods);
     }
     {
-        B_SequenceG_methods.$GCINFO = "B_Sequence";
+        memset(B_SequenceD_gcbm, 0xFF, sizeof(B_SequenceD_gcbm));
+        B_SequenceG_methods.$GCdescr = GC_make_descriptor(B_SequenceD_gcbm, GC_WORD_LEN(struct B_Sequence));
+        B_SequenceG_methods.$name = "B_Sequence";
         B_SequenceG_methods.$superclass = ($SuperG_class)&B_SliceableG_methods;
         B_SequenceG_methods.__bool__ = (B_bool (*) (B_Sequence))B_valueG_methods.__bool__;
         B_SequenceG_methods.__str__ = (B_str (*) (B_Sequence))B_valueG_methods.__str__;
@@ -6325,7 +6715,9 @@ void B___init__ () {
         $register(&B_SequenceG_methods);
     }
     {
-        B_CollectionD_SequenceG_methods.$GCINFO = "B_CollectionD_Sequence";
+        memset(B_CollectionD_SequenceD_gcbm, 0xFF, sizeof(B_CollectionD_SequenceD_gcbm));
+        B_CollectionD_SequenceG_methods.$GCdescr = GC_make_descriptor(B_CollectionD_SequenceD_gcbm, GC_WORD_LEN(struct B_CollectionD_Sequence));
+        B_CollectionD_SequenceG_methods.$name = "B_CollectionD_Sequence";
         B_CollectionD_SequenceG_methods.$superclass = ($SuperG_class)&B_CollectionG_methods;
         B_CollectionD_SequenceG_methods.__bool__ = (B_bool (*) (B_CollectionD_Sequence))B_valueG_methods.__bool__;
         B_CollectionD_SequenceG_methods.__str__ = (B_str (*) (B_CollectionD_Sequence))B_valueG_methods.__str__;
@@ -6336,7 +6728,9 @@ void B___init__ () {
         $register(&B_CollectionD_SequenceG_methods);
     }
     {
-        B_TimesD_SequenceG_methods.$GCINFO = "B_TimesD_Sequence";
+        memset(B_TimesD_SequenceD_gcbm, 0xFF, sizeof(B_TimesD_SequenceD_gcbm));
+        B_TimesD_SequenceG_methods.$GCdescr = GC_make_descriptor(B_TimesD_SequenceD_gcbm, GC_WORD_LEN(struct B_TimesD_Sequence));
+        B_TimesD_SequenceG_methods.$name = "B_TimesD_Sequence";
         B_TimesD_SequenceG_methods.$superclass = ($SuperG_class)&B_TimesG_methods;
         B_TimesD_SequenceG_methods.__bool__ = (B_bool (*) (B_TimesD_Sequence))B_valueG_methods.__bool__;
         B_TimesD_SequenceG_methods.__str__ = (B_str (*) (B_TimesD_Sequence))B_valueG_methods.__str__;
@@ -6349,7 +6743,9 @@ void B___init__ () {
         $register(&B_TimesD_SequenceG_methods);
     }
     {
-        B_MappingG_methods.$GCINFO = "B_Mapping";
+        memset(B_MappingD_gcbm, 0xFF, sizeof(B_MappingD_gcbm));
+        B_MappingG_methods.$GCdescr = GC_make_descriptor(B_MappingD_gcbm, GC_WORD_LEN(struct B_Mapping));
+        B_MappingG_methods.$name = "B_Mapping";
         B_MappingG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods;
         B_MappingG_methods.__bool__ = (B_bool (*) (B_Mapping))B_valueG_methods.__bool__;
         B_MappingG_methods.__str__ = (B_str (*) (B_Mapping))B_valueG_methods.__str__;
@@ -6360,7 +6756,9 @@ void B___init__ () {
         $register(&B_MappingG_methods);
     }
     {
-        B_IndexedD_MappingG_methods.$GCINFO = "B_IndexedD_Mapping";
+        memset(B_IndexedD_MappingD_gcbm, 0xFF, sizeof(B_IndexedD_MappingD_gcbm));
+        B_IndexedD_MappingG_methods.$GCdescr = GC_make_descriptor(B_IndexedD_MappingD_gcbm, GC_WORD_LEN(struct B_IndexedD_Mapping));
+        B_IndexedD_MappingG_methods.$name = "B_IndexedD_Mapping";
         B_IndexedD_MappingG_methods.$superclass = ($SuperG_class)&B_IndexedG_methods;
         B_IndexedD_MappingG_methods.__bool__ = (B_bool (*) (B_IndexedD_Mapping))B_valueG_methods.__bool__;
         B_IndexedD_MappingG_methods.__str__ = (B_str (*) (B_IndexedD_Mapping))B_valueG_methods.__str__;
@@ -6371,7 +6769,9 @@ void B___init__ () {
         $register(&B_IndexedD_MappingG_methods);
     }
     {
-        B_SetG_methods.$GCINFO = "B_Set";
+        memset(B_SetD_gcbm, 0xFF, sizeof(B_SetD_gcbm));
+        B_SetG_methods.$GCdescr = GC_make_descriptor(B_SetD_gcbm, GC_WORD_LEN(struct B_Set));
+        B_SetG_methods.$name = "B_Set";
         B_SetG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods;
         B_SetG_methods.__bool__ = (B_bool (*) (B_Set))B_valueG_methods.__bool__;
         B_SetG_methods.__str__ = (B_str (*) (B_Set))B_valueG_methods.__str__;
@@ -6382,7 +6782,9 @@ void B___init__ () {
         $register(&B_SetG_methods);
     }
     {
-        B_OrdD_SetG_methods.$GCINFO = "B_OrdD_Set";
+        memset(B_OrdD_SetD_gcbm, 0xFF, sizeof(B_OrdD_SetD_gcbm));
+        B_OrdD_SetG_methods.$GCdescr = GC_make_descriptor(B_OrdD_SetD_gcbm, GC_WORD_LEN(struct B_OrdD_Set));
+        B_OrdD_SetG_methods.$name = "B_OrdD_Set";
         B_OrdD_SetG_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_SetG_methods.__bool__ = (B_bool (*) (B_OrdD_Set))B_valueG_methods.__bool__;
         B_OrdD_SetG_methods.__str__ = (B_str (*) (B_OrdD_Set))B_valueG_methods.__str__;
@@ -6397,7 +6799,9 @@ void B___init__ () {
         $register(&B_OrdD_SetG_methods);
     }
     {
-        B_LogicalD_SetG_methods.$GCINFO = "B_LogicalD_Set";
+        memset(B_LogicalD_SetD_gcbm, 0xFF, sizeof(B_LogicalD_SetD_gcbm));
+        B_LogicalD_SetG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_SetD_gcbm, GC_WORD_LEN(struct B_LogicalD_Set));
+        B_LogicalD_SetG_methods.$name = "B_LogicalD_Set";
         B_LogicalD_SetG_methods.$superclass = ($SuperG_class)&B_LogicalG_methods;
         B_LogicalD_SetG_methods.__bool__ = (B_bool (*) (B_LogicalD_Set))B_valueG_methods.__bool__;
         B_LogicalD_SetG_methods.__str__ = (B_str (*) (B_LogicalD_Set))B_valueG_methods.__str__;
@@ -6411,7 +6815,9 @@ void B___init__ () {
         $register(&B_LogicalD_SetG_methods);
     }
     {
-        B_MinusD_SetG_methods.$GCINFO = "B_MinusD_Set";
+        memset(B_MinusD_SetD_gcbm, 0xFF, sizeof(B_MinusD_SetD_gcbm));
+        B_MinusD_SetG_methods.$GCdescr = GC_make_descriptor(B_MinusD_SetD_gcbm, GC_WORD_LEN(struct B_MinusD_Set));
+        B_MinusD_SetG_methods.$name = "B_MinusD_Set";
         B_MinusD_SetG_methods.$superclass = ($SuperG_class)&B_MinusG_methods;
         B_MinusD_SetG_methods.__bool__ = (B_bool (*) (B_MinusD_Set))B_valueG_methods.__bool__;
         B_MinusD_SetG_methods.__str__ = (B_str (*) (B_MinusD_Set))B_valueG_methods.__str__;
@@ -6423,7 +6829,9 @@ void B___init__ () {
         $register(&B_MinusD_SetG_methods);
     }
     {
-        B_SequenceD_listG_methods.$GCINFO = "B_SequenceD_list";
+        memset(B_SequenceD_listD_gcbm, 0xFF, sizeof(B_SequenceD_listD_gcbm));
+        B_SequenceD_listG_methods.$GCdescr = GC_make_descriptor(B_SequenceD_listD_gcbm, GC_WORD_LEN(struct B_SequenceD_list));
+        B_SequenceD_listG_methods.$name = "B_SequenceD_list";
         B_SequenceD_listG_methods.$superclass = ($SuperG_class)&B_SequenceG_methods;
         B_SequenceD_listG_methods.__bool__ = (B_bool (*) (B_SequenceD_list))B_valueG_methods.__bool__;
         B_SequenceD_listG_methods.__str__ = (B_str (*) (B_SequenceD_list))B_valueG_methods.__str__;
@@ -6444,7 +6852,9 @@ void B___init__ () {
         $register(&B_SequenceD_listG_methods);
     }
     {
-        B_CollectionD_SequenceD_listG_methods.$GCINFO = "B_CollectionD_SequenceD_list";
+        memset(B_CollectionD_SequenceD_listD_gcbm, 0xFF, sizeof(B_CollectionD_SequenceD_listD_gcbm));
+        B_CollectionD_SequenceD_listG_methods.$GCdescr = GC_make_descriptor(B_CollectionD_SequenceD_listD_gcbm, GC_WORD_LEN(struct B_CollectionD_SequenceD_list));
+        B_CollectionD_SequenceD_listG_methods.$name = "B_CollectionD_SequenceD_list";
         B_CollectionD_SequenceD_listG_methods.$superclass = ($SuperG_class)&B_CollectionD_SequenceG_methods;
         B_CollectionD_SequenceD_listG_methods.__bool__ = (B_bool (*) (B_CollectionD_SequenceD_list))B_valueG_methods.__bool__;
         B_CollectionD_SequenceD_listG_methods.__str__ = (B_str (*) (B_CollectionD_SequenceD_list))B_valueG_methods.__str__;
@@ -6458,7 +6868,9 @@ void B___init__ () {
         $register(&B_CollectionD_SequenceD_listG_methods);
     }
     {
-        B_TimesD_SequenceD_listG_methods.$GCINFO = "B_TimesD_SequenceD_list";
+        memset(B_TimesD_SequenceD_listD_gcbm, 0xFF, sizeof(B_TimesD_SequenceD_listD_gcbm));
+        B_TimesD_SequenceD_listG_methods.$GCdescr = GC_make_descriptor(B_TimesD_SequenceD_listD_gcbm, GC_WORD_LEN(struct B_TimesD_SequenceD_list));
+        B_TimesD_SequenceD_listG_methods.$name = "B_TimesD_SequenceD_list";
         B_TimesD_SequenceD_listG_methods.$superclass = ($SuperG_class)&B_TimesD_SequenceG_methods;
         B_TimesD_SequenceD_listG_methods.__bool__ = (B_bool (*) (B_TimesD_SequenceD_list))B_valueG_methods.__bool__;
         B_TimesD_SequenceD_listG_methods.__str__ = (B_str (*) (B_TimesD_SequenceD_list))B_valueG_methods.__str__;
@@ -6473,7 +6885,9 @@ void B___init__ () {
         $register(&B_TimesD_SequenceD_listG_methods);
     }
     {
-        B_ContainerD_listG_methods.$GCINFO = "B_ContainerD_list";
+        memset(B_ContainerD_listD_gcbm, 0xFF, sizeof(B_ContainerD_listD_gcbm));
+        B_ContainerD_listG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_listD_gcbm, GC_WORD_LEN(struct B_ContainerD_list));
+        B_ContainerD_listG_methods.$name = "B_ContainerD_list";
         B_ContainerD_listG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods;
         B_ContainerD_listG_methods.__bool__ = (B_bool (*) (B_ContainerD_list))B_valueG_methods.__bool__;
         B_ContainerD_listG_methods.__str__ = (B_str (*) (B_ContainerD_list))B_valueG_methods.__str__;
@@ -6486,7 +6900,9 @@ void B___init__ () {
         $register(&B_ContainerD_listG_methods);
     }
     {
-        B_OrdD_listG_methods.$GCINFO = "B_OrdD_list";
+        memset(B_OrdD_listD_gcbm, 0xFF, sizeof(B_OrdD_listD_gcbm));
+        B_OrdD_listG_methods.$GCdescr = GC_make_descriptor(B_OrdD_listD_gcbm, GC_WORD_LEN(struct B_OrdD_list));
+        B_OrdD_listG_methods.$name = "B_OrdD_list";
         B_OrdD_listG_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_listG_methods.__bool__ = (B_bool (*) (B_OrdD_list))B_valueG_methods.__bool__;
         B_OrdD_listG_methods.__str__ = (B_str (*) (B_OrdD_list))B_valueG_methods.__str__;
@@ -6503,7 +6919,9 @@ void B___init__ () {
         $register(&B_OrdD_listG_methods);
     }
     {
-        B_MappingD_dictG_methods.$GCINFO = "B_MappingD_dict";
+        memset(B_MappingD_dictD_gcbm, 0xFF, sizeof(B_MappingD_dictD_gcbm));
+        B_MappingD_dictG_methods.$GCdescr = GC_make_descriptor(B_MappingD_dictD_gcbm, GC_WORD_LEN(struct B_MappingD_dict));
+        B_MappingD_dictG_methods.$name = "B_MappingD_dict";
         B_MappingD_dictG_methods.$superclass = ($SuperG_class)&B_MappingG_methods;
         B_MappingD_dictG_methods.__bool__ = (B_bool (*) (B_MappingD_dict))B_valueG_methods.__bool__;
         B_MappingD_dictG_methods.__str__ = (B_str (*) (B_MappingD_dict))B_valueG_methods.__str__;
@@ -6526,7 +6944,9 @@ void B___init__ () {
         $register(&B_MappingD_dictG_methods);
     }
     {
-        B_IndexedD_MappingD_dictG_methods.$GCINFO = "B_IndexedD_MappingD_dict";
+        memset(B_IndexedD_MappingD_dictD_gcbm, 0xFF, sizeof(B_IndexedD_MappingD_dictD_gcbm));
+        B_IndexedD_MappingD_dictG_methods.$GCdescr = GC_make_descriptor(B_IndexedD_MappingD_dictD_gcbm, GC_WORD_LEN(struct B_IndexedD_MappingD_dict));
+        B_IndexedD_MappingD_dictG_methods.$name = "B_IndexedD_MappingD_dict";
         B_IndexedD_MappingD_dictG_methods.$superclass = ($SuperG_class)&B_IndexedD_MappingG_methods;
         B_IndexedD_MappingD_dictG_methods.__bool__ = (B_bool (*) (B_IndexedD_MappingD_dict))B_valueG_methods.__bool__;
         B_IndexedD_MappingD_dictG_methods.__str__ = (B_str (*) (B_IndexedD_MappingD_dict))B_valueG_methods.__str__;
@@ -6540,7 +6960,9 @@ void B___init__ () {
         $register(&B_IndexedD_MappingD_dictG_methods);
     }
     {
-        B_OrdD_dictG_methods.$GCINFO = "B_OrdD_dict";
+        memset(B_OrdD_dictD_gcbm, 0xFF, sizeof(B_OrdD_dictD_gcbm));
+        B_OrdD_dictG_methods.$GCdescr = GC_make_descriptor(B_OrdD_dictD_gcbm, GC_WORD_LEN(struct B_OrdD_dict));
+        B_OrdD_dictG_methods.$name = "B_OrdD_dict";
         B_OrdD_dictG_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_dictG_methods.__bool__ = (B_bool (*) (B_OrdD_dict))B_valueG_methods.__bool__;
         B_OrdD_dictG_methods.__str__ = (B_str (*) (B_OrdD_dict))B_valueG_methods.__str__;
@@ -6557,7 +6979,9 @@ void B___init__ () {
         $register(&B_OrdD_dictG_methods);
     }
     {
-        B_SetD_setG_methods.$GCINFO = "B_SetD_set";
+        memset(B_SetD_setD_gcbm, 0xFF, sizeof(B_SetD_setD_gcbm));
+        B_SetD_setG_methods.$GCdescr = GC_make_descriptor(B_SetD_setD_gcbm, GC_WORD_LEN(struct B_SetD_set));
+        B_SetD_setG_methods.$name = "B_SetD_set";
         B_SetD_setG_methods.$superclass = ($SuperG_class)&B_SetG_methods;
         B_SetD_setG_methods.__bool__ = (B_bool (*) (B_SetD_set))B_valueG_methods.__bool__;
         B_SetD_setG_methods.__str__ = (B_str (*) (B_SetD_set))B_valueG_methods.__str__;
@@ -6577,7 +7001,9 @@ void B___init__ () {
         $register(&B_SetD_setG_methods);
     }
     {
-        B_OrdD_SetD_setG_methods.$GCINFO = "B_OrdD_SetD_set";
+        memset(B_OrdD_SetD_setD_gcbm, 0xFF, sizeof(B_OrdD_SetD_setD_gcbm));
+        B_OrdD_SetD_setG_methods.$GCdescr = GC_make_descriptor(B_OrdD_SetD_setD_gcbm, GC_WORD_LEN(struct B_OrdD_SetD_set));
+        B_OrdD_SetD_setG_methods.$name = "B_OrdD_SetD_set";
         B_OrdD_SetD_setG_methods.$superclass = ($SuperG_class)&B_OrdD_SetG_methods;
         B_OrdD_SetD_setG_methods.__bool__ = (B_bool (*) (B_OrdD_SetD_set))B_valueG_methods.__bool__;
         B_OrdD_SetD_setG_methods.__str__ = (B_str (*) (B_OrdD_SetD_set))B_valueG_methods.__str__;
@@ -6594,7 +7020,9 @@ void B___init__ () {
         $register(&B_OrdD_SetD_setG_methods);
     }
     {
-        B_LogicalD_SetD_setG_methods.$GCINFO = "B_LogicalD_SetD_set";
+        memset(B_LogicalD_SetD_setD_gcbm, 0xFF, sizeof(B_LogicalD_SetD_setD_gcbm));
+        B_LogicalD_SetD_setG_methods.$GCdescr = GC_make_descriptor(B_LogicalD_SetD_setD_gcbm, GC_WORD_LEN(struct B_LogicalD_SetD_set));
+        B_LogicalD_SetD_setG_methods.$name = "B_LogicalD_SetD_set";
         B_LogicalD_SetD_setG_methods.$superclass = ($SuperG_class)&B_LogicalD_SetG_methods;
         B_LogicalD_SetD_setG_methods.__bool__ = (B_bool (*) (B_LogicalD_SetD_set))B_valueG_methods.__bool__;
         B_LogicalD_SetD_setG_methods.__str__ = (B_str (*) (B_LogicalD_SetD_set))B_valueG_methods.__str__;
@@ -6611,7 +7039,9 @@ void B___init__ () {
         $register(&B_LogicalD_SetD_setG_methods);
     }
     {
-        B_MinusD_SetD_setG_methods.$GCINFO = "B_MinusD_SetD_set";
+        memset(B_MinusD_SetD_setD_gcbm, 0xFF, sizeof(B_MinusD_SetD_setD_gcbm));
+        B_MinusD_SetD_setG_methods.$GCdescr = GC_make_descriptor(B_MinusD_SetD_setD_gcbm, GC_WORD_LEN(struct B_MinusD_SetD_set));
+        B_MinusD_SetD_setG_methods.$name = "B_MinusD_SetD_set";
         B_MinusD_SetD_setG_methods.$superclass = ($SuperG_class)&B_MinusD_SetG_methods;
         B_MinusD_SetD_setG_methods.__bool__ = (B_bool (*) (B_MinusD_SetD_set))B_valueG_methods.__bool__;
         B_MinusD_SetD_setG_methods.__str__ = (B_str (*) (B_MinusD_SetD_set))B_valueG_methods.__str__;
@@ -6624,7 +7054,9 @@ void B___init__ () {
         $register(&B_MinusD_SetD_setG_methods);
     }
     {
-        B_IterableD_IteratorG_methods.$GCINFO = "B_IterableD_Iterator";
+        memset(B_IterableD_IteratorD_gcbm, 0xFF, sizeof(B_IterableD_IteratorD_gcbm));
+        B_IterableD_IteratorG_methods.$GCdescr = GC_make_descriptor(B_IterableD_IteratorD_gcbm, GC_WORD_LEN(struct B_IterableD_Iterator));
+        B_IterableD_IteratorG_methods.$name = "B_IterableD_Iterator";
         B_IterableD_IteratorG_methods.$superclass = ($SuperG_class)&B_IterableG_methods;
         B_IterableD_IteratorG_methods.__bool__ = (B_bool (*) (B_IterableD_Iterator))B_valueG_methods.__bool__;
         B_IterableD_IteratorG_methods.__str__ = (B_str (*) (B_IterableD_Iterator))B_valueG_methods.__str__;
@@ -6636,7 +7068,9 @@ void B___init__ () {
         $register(&B_IterableD_IteratorG_methods);
     }
     {
-        B_IterableD_rangeG_methods.$GCINFO = "B_IterableD_range";
+        memset(B_IterableD_rangeD_gcbm, 0xFF, sizeof(B_IterableD_rangeD_gcbm));
+        B_IterableD_rangeG_methods.$GCdescr = GC_make_descriptor(B_IterableD_rangeD_gcbm, GC_WORD_LEN(struct B_IterableD_range));
+        B_IterableD_rangeG_methods.$name = "B_IterableD_range";
         B_IterableD_rangeG_methods.$superclass = ($SuperG_class)&B_IterableG_methods;
         B_IterableD_rangeG_methods.__bool__ = (B_bool (*) (B_IterableD_range))B_valueG_methods.__bool__;
         B_IterableD_rangeG_methods.__str__ = (B_str (*) (B_IterableD_range))B_valueG_methods.__str__;
@@ -6648,7 +7082,9 @@ void B___init__ () {
         $register(&B_IterableD_rangeG_methods);
     }
     {
-        B_OrdD_strG_methods.$GCINFO = "B_OrdD_str";
+        memset(B_OrdD_strD_gcbm, 0xFF, sizeof(B_OrdD_strD_gcbm));
+        B_OrdD_strG_methods.$GCdescr = GC_make_descriptor(B_OrdD_strD_gcbm, GC_WORD_LEN(struct B_OrdD_str));
+        B_OrdD_strG_methods.$name = "B_OrdD_str";
         B_OrdD_strG_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_strG_methods.__bool__ = (B_bool (*) (B_OrdD_str))B_valueG_methods.__bool__;
         B_OrdD_strG_methods.__str__ = (B_str (*) (B_OrdD_str))B_valueG_methods.__str__;
@@ -6665,7 +7101,9 @@ void B___init__ () {
         $register(&B_OrdD_strG_methods);
     }
     {
-        B_ContainerD_strG_methods.$GCINFO = "B_ContainerD_str";
+        memset(B_ContainerD_strD_gcbm, 0xFF, sizeof(B_ContainerD_strD_gcbm));
+        B_ContainerD_strG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_strD_gcbm, GC_WORD_LEN(struct B_ContainerD_str));
+        B_ContainerD_strG_methods.$name = "B_ContainerD_str";
         B_ContainerD_strG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods;
         B_ContainerD_strG_methods.__bool__ = (B_bool (*) (B_ContainerD_str))B_valueG_methods.__bool__;
         B_ContainerD_strG_methods.__str__ = (B_str (*) (B_ContainerD_str))B_valueG_methods.__str__;
@@ -6681,7 +7119,9 @@ void B___init__ () {
         $register(&B_ContainerD_strG_methods);
     }
     {
-        B_SliceableD_strG_methods.$GCINFO = "B_SliceableD_str";
+        memset(B_SliceableD_strD_gcbm, 0xFF, sizeof(B_SliceableD_strD_gcbm));
+        B_SliceableD_strG_methods.$GCdescr = GC_make_descriptor(B_SliceableD_strD_gcbm, GC_WORD_LEN(struct B_SliceableD_str));
+        B_SliceableD_strG_methods.$name = "B_SliceableD_str";
         B_SliceableD_strG_methods.$superclass = ($SuperG_class)&B_SliceableG_methods;
         B_SliceableD_strG_methods.__bool__ = (B_bool (*) (B_SliceableD_str))B_valueG_methods.__bool__;
         B_SliceableD_strG_methods.__str__ = (B_str (*) (B_SliceableD_str))B_valueG_methods.__str__;
@@ -6698,7 +7138,9 @@ void B___init__ () {
         $register(&B_SliceableD_strG_methods);
     }
     {
-        B_TimesD_strG_methods.$GCINFO = "B_TimesD_str";
+        memset(B_TimesD_strD_gcbm, 0xFF, sizeof(B_TimesD_strD_gcbm));
+        B_TimesD_strG_methods.$GCdescr = GC_make_descriptor(B_TimesD_strD_gcbm, GC_WORD_LEN(struct B_TimesD_str));
+        B_TimesD_strG_methods.$name = "B_TimesD_str";
         B_TimesD_strG_methods.$superclass = ($SuperG_class)&B_TimesG_methods;
         B_TimesD_strG_methods.__bool__ = (B_bool (*) (B_TimesD_str))B_valueG_methods.__bool__;
         B_TimesD_strG_methods.__str__ = (B_str (*) (B_TimesD_str))B_valueG_methods.__str__;
@@ -6713,7 +7155,9 @@ void B___init__ () {
         $register(&B_TimesD_strG_methods);
     }
     {
-        B_HashableD_strG_methods.$GCINFO = "B_HashableD_str";
+        memset(B_HashableD_strD_gcbm, 0xFF, sizeof(B_HashableD_strD_gcbm));
+        B_HashableD_strG_methods.$GCdescr = GC_make_descriptor(B_HashableD_strD_gcbm, GC_WORD_LEN(struct B_HashableD_str));
+        B_HashableD_strG_methods.$name = "B_HashableD_str";
         B_HashableD_strG_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_strG_methods.__bool__ = (B_bool (*) (B_HashableD_str))B_valueG_methods.__bool__;
         B_HashableD_strG_methods.__str__ = (B_str (*) (B_HashableD_str))B_valueG_methods.__str__;
@@ -6727,7 +7171,9 @@ void B___init__ () {
         $register(&B_HashableD_strG_methods);
     }
     {
-        B_OrdD_bytearrayG_methods.$GCINFO = "B_OrdD_bytearray";
+        memset(B_OrdD_bytearrayD_gcbm, 0xFF, sizeof(B_OrdD_bytearrayD_gcbm));
+        B_OrdD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_OrdD_bytearrayD_gcbm, GC_WORD_LEN(struct B_OrdD_bytearray));
+        B_OrdD_bytearrayG_methods.$name = "B_OrdD_bytearray";
         B_OrdD_bytearrayG_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_bytearrayG_methods.__bool__ = (B_bool (*) (B_OrdD_bytearray))B_valueG_methods.__bool__;
         B_OrdD_bytearrayG_methods.__str__ = (B_str (*) (B_OrdD_bytearray))B_valueG_methods.__str__;
@@ -6744,7 +7190,9 @@ void B___init__ () {
         $register(&B_OrdD_bytearrayG_methods);
     }
     {
-        B_SequenceD_bytearrayG_methods.$GCINFO = "B_SequenceD_bytearray";
+        memset(B_SequenceD_bytearrayD_gcbm, 0xFF, sizeof(B_SequenceD_bytearrayD_gcbm));
+        B_SequenceD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_SequenceD_bytearrayD_gcbm, GC_WORD_LEN(struct B_SequenceD_bytearray));
+        B_SequenceD_bytearrayG_methods.$name = "B_SequenceD_bytearray";
         B_SequenceD_bytearrayG_methods.$superclass = ($SuperG_class)&B_SequenceG_methods;
         B_SequenceD_bytearrayG_methods.__bool__ = (B_bool (*) (B_SequenceD_bytearray))B_valueG_methods.__bool__;
         B_SequenceD_bytearrayG_methods.__str__ = (B_str (*) (B_SequenceD_bytearray))B_valueG_methods.__str__;
@@ -6765,7 +7213,9 @@ void B___init__ () {
         $register(&B_SequenceD_bytearrayG_methods);
     }
     {
-        B_CollectionD_SequenceD_bytearrayG_methods.$GCINFO = "B_CollectionD_SequenceD_bytearray";
+        memset(B_CollectionD_SequenceD_bytearrayD_gcbm, 0xFF, sizeof(B_CollectionD_SequenceD_bytearrayD_gcbm));
+        B_CollectionD_SequenceD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_CollectionD_SequenceD_bytearrayD_gcbm, GC_WORD_LEN(struct B_CollectionD_SequenceD_bytearray));
+        B_CollectionD_SequenceD_bytearrayG_methods.$name = "B_CollectionD_SequenceD_bytearray";
         B_CollectionD_SequenceD_bytearrayG_methods.$superclass = ($SuperG_class)&B_CollectionD_SequenceG_methods;
         B_CollectionD_SequenceD_bytearrayG_methods.__bool__ = (B_bool (*) (B_CollectionD_SequenceD_bytearray))B_valueG_methods.__bool__;
         B_CollectionD_SequenceD_bytearrayG_methods.__str__ = (B_str (*) (B_CollectionD_SequenceD_bytearray))B_valueG_methods.__str__;
@@ -6779,7 +7229,9 @@ void B___init__ () {
         $register(&B_CollectionD_SequenceD_bytearrayG_methods);
     }
     {
-        B_TimesD_SequenceD_bytearrayG_methods.$GCINFO = "B_TimesD_SequenceD_bytearray";
+        memset(B_TimesD_SequenceD_bytearrayD_gcbm, 0xFF, sizeof(B_TimesD_SequenceD_bytearrayD_gcbm));
+        B_TimesD_SequenceD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_TimesD_SequenceD_bytearrayD_gcbm, GC_WORD_LEN(struct B_TimesD_SequenceD_bytearray));
+        B_TimesD_SequenceD_bytearrayG_methods.$name = "B_TimesD_SequenceD_bytearray";
         B_TimesD_SequenceD_bytearrayG_methods.$superclass = ($SuperG_class)&B_TimesD_SequenceG_methods;
         B_TimesD_SequenceD_bytearrayG_methods.__bool__ = (B_bool (*) (B_TimesD_SequenceD_bytearray))B_valueG_methods.__bool__;
         B_TimesD_SequenceD_bytearrayG_methods.__str__ = (B_str (*) (B_TimesD_SequenceD_bytearray))B_valueG_methods.__str__;
@@ -6794,7 +7246,9 @@ void B___init__ () {
         $register(&B_TimesD_SequenceD_bytearrayG_methods);
     }
     {
-        B_ContainerD_bytearrayG_methods.$GCINFO = "B_ContainerD_bytearray";
+        memset(B_ContainerD_bytearrayD_gcbm, 0xFF, sizeof(B_ContainerD_bytearrayD_gcbm));
+        B_ContainerD_bytearrayG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_bytearrayD_gcbm, GC_WORD_LEN(struct B_ContainerD_bytearray));
+        B_ContainerD_bytearrayG_methods.$name = "B_ContainerD_bytearray";
         B_ContainerD_bytearrayG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods;
         B_ContainerD_bytearrayG_methods.__bool__ = (B_bool (*) (B_ContainerD_bytearray))B_valueG_methods.__bool__;
         B_ContainerD_bytearrayG_methods.__str__ = (B_str (*) (B_ContainerD_bytearray))B_valueG_methods.__str__;
@@ -6807,7 +7261,9 @@ void B___init__ () {
         $register(&B_ContainerD_bytearrayG_methods);
     }
     {
-        B_OrdD_bytesG_methods.$GCINFO = "B_OrdD_bytes";
+        memset(B_OrdD_bytesD_gcbm, 0xFF, sizeof(B_OrdD_bytesD_gcbm));
+        B_OrdD_bytesG_methods.$GCdescr = GC_make_descriptor(B_OrdD_bytesD_gcbm, GC_WORD_LEN(struct B_OrdD_bytes));
+        B_OrdD_bytesG_methods.$name = "B_OrdD_bytes";
         B_OrdD_bytesG_methods.$superclass = ($SuperG_class)&B_OrdG_methods;
         B_OrdD_bytesG_methods.__bool__ = (B_bool (*) (B_OrdD_bytes))B_valueG_methods.__bool__;
         B_OrdD_bytesG_methods.__str__ = (B_str (*) (B_OrdD_bytes))B_valueG_methods.__str__;
@@ -6824,7 +7280,9 @@ void B___init__ () {
         $register(&B_OrdD_bytesG_methods);
     }
     {
-        B_SliceableD_bytesG_methods.$GCINFO = "B_SliceableD_bytes";
+        memset(B_SliceableD_bytesD_gcbm, 0xFF, sizeof(B_SliceableD_bytesD_gcbm));
+        B_SliceableD_bytesG_methods.$GCdescr = GC_make_descriptor(B_SliceableD_bytesD_gcbm, GC_WORD_LEN(struct B_SliceableD_bytes));
+        B_SliceableD_bytesG_methods.$name = "B_SliceableD_bytes";
         B_SliceableD_bytesG_methods.$superclass = ($SuperG_class)&B_SliceableG_methods;
         B_SliceableD_bytesG_methods.__bool__ = (B_bool (*) (B_SliceableD_bytes))B_valueG_methods.__bool__;
         B_SliceableD_bytesG_methods.__str__ = (B_str (*) (B_SliceableD_bytes))B_valueG_methods.__str__;
@@ -6841,7 +7299,9 @@ void B___init__ () {
         $register(&B_SliceableD_bytesG_methods);
     }
     {
-        B_ContainerD_bytesG_methods.$GCINFO = "B_ContainerD_bytes";
+        memset(B_ContainerD_bytesD_gcbm, 0xFF, sizeof(B_ContainerD_bytesD_gcbm));
+        B_ContainerD_bytesG_methods.$GCdescr = GC_make_descriptor(B_ContainerD_bytesD_gcbm, GC_WORD_LEN(struct B_ContainerD_bytes));
+        B_ContainerD_bytesG_methods.$name = "B_ContainerD_bytes";
         B_ContainerD_bytesG_methods.$superclass = ($SuperG_class)&B_ContainerG_methods;
         B_ContainerD_bytesG_methods.__bool__ = (B_bool (*) (B_ContainerD_bytes))B_valueG_methods.__bool__;
         B_ContainerD_bytesG_methods.__str__ = (B_str (*) (B_ContainerD_bytes))B_valueG_methods.__str__;
@@ -6857,7 +7317,9 @@ void B___init__ () {
         $register(&B_ContainerD_bytesG_methods);
     }
     {
-        B_TimesD_bytesG_methods.$GCINFO = "B_TimesD_bytes";
+        memset(B_TimesD_bytesD_gcbm, 0xFF, sizeof(B_TimesD_bytesD_gcbm));
+        B_TimesD_bytesG_methods.$GCdescr = GC_make_descriptor(B_TimesD_bytesD_gcbm, GC_WORD_LEN(struct B_TimesD_bytes));
+        B_TimesD_bytesG_methods.$name = "B_TimesD_bytes";
         B_TimesD_bytesG_methods.$superclass = ($SuperG_class)&B_TimesG_methods;
         B_TimesD_bytesG_methods.__bool__ = (B_bool (*) (B_TimesD_bytes))B_valueG_methods.__bool__;
         B_TimesD_bytesG_methods.__str__ = (B_str (*) (B_TimesD_bytes))B_valueG_methods.__str__;
@@ -6872,7 +7334,9 @@ void B___init__ () {
         $register(&B_TimesD_bytesG_methods);
     }
     {
-        B_HashableD_bytesG_methods.$GCINFO = "B_HashableD_bytes";
+        memset(B_HashableD_bytesD_gcbm, 0xFF, sizeof(B_HashableD_bytesD_gcbm));
+        B_HashableD_bytesG_methods.$GCdescr = GC_make_descriptor(B_HashableD_bytesD_gcbm, GC_WORD_LEN(struct B_HashableD_bytes));
+        B_HashableD_bytesG_methods.$name = "B_HashableD_bytes";
         B_HashableD_bytesG_methods.$superclass = ($SuperG_class)&B_HashableG_methods;
         B_HashableD_bytesG_methods.__bool__ = (B_bool (*) (B_HashableD_bytes))B_valueG_methods.__bool__;
         B_HashableD_bytesG_methods.__str__ = (B_str (*) (B_HashableD_bytes))B_valueG_methods.__str__;
@@ -6886,7 +7350,9 @@ void B___init__ () {
     }
     /*
     {
-        B_L_1procG_methods.$GCINFO = "B_L_1proc";
+        memset(B_L_1procD_gcbm, 0xFF, sizeof(B_L_1procD_gcbm));
+        B_L_1procG_methods.$GCdescr = GC_make_descriptor(B_L_1procD_gcbm, GC_WORD_LEN(struct B_L_1proc));
+        B_L_1procG_methods.$name = "B_L_1proc";
         B_L_1procG_methods.$superclass = ($SuperG_class)&$procG_methods;
         B_L_1procG_methods.__bool__ = (B_bool (*) (B_L_1proc))B_valueG_methods.__bool__;
         B_L_1procG_methods.__str__ = (B_str (*) (B_L_1proc))B_valueG_methods.__str__;
@@ -6899,7 +7365,9 @@ void B___init__ () {
         $register(&B_L_1procG_methods);
     }
     {
-        B_L_2procG_methods.$GCINFO = "B_L_2proc";
+        memset(B_L_2procD_gcbm, 0xFF, sizeof(B_L_2procD_gcbm));
+        B_L_2procG_methods.$GCdescr = GC_make_descriptor(B_L_2procD_gcbm, GC_WORD_LEN(struct B_L_2proc));
+        B_L_2procG_methods.$name = "B_L_2proc";
         B_L_2procG_methods.$superclass = ($SuperG_class)&$procG_methods;
         B_L_2procG_methods.__bool__ = (B_bool (*) (B_L_2proc))B_valueG_methods.__bool__;
         B_L_2procG_methods.__str__ = (B_str (*) (B_L_2proc))B_valueG_methods.__str__;
@@ -6912,7 +7380,9 @@ void B___init__ () {
         $register(&B_L_2procG_methods);
     }
     {
-        B_L_3procG_methods.$GCINFO = "B_L_3proc";
+        memset(B_L_3procD_gcbm, 0xFF, sizeof(B_L_3procD_gcbm));
+        B_L_3procG_methods.$GCdescr = GC_make_descriptor(B_L_3procD_gcbm, GC_WORD_LEN(struct B_L_3proc));
+        B_L_3procG_methods.$name = "B_L_3proc";
         B_L_3procG_methods.$superclass = ($SuperG_class)&$procG_methods;
         B_L_3procG_methods.__bool__ = (B_bool (*) (B_L_3proc))B_valueG_methods.__bool__;
         B_L_3procG_methods.__str__ = (B_str (*) (B_L_3proc))B_valueG_methods.__str__;
@@ -6925,7 +7395,9 @@ void B___init__ () {
         $register(&B_L_3procG_methods);
     }
     {
-        B_L_5ContG_methods.$GCINFO = "B_L_5Cont";
+        memset(B_L_5ContD_gcbm, 0xFF, sizeof(B_L_5ContD_gcbm));
+        B_L_5ContG_methods.$GCdescr = GC_make_descriptor(B_L_5ContD_gcbm, GC_WORD_LEN(struct B_L_5Cont));
+        B_L_5ContG_methods.$name = "B_L_5Cont";
         B_L_5ContG_methods.$superclass = ($SuperG_class)&$ContG_methods;
         B_L_5ContG_methods.__bool__ = (B_bool (*) (B_L_5Cont))B_valueG_methods.__bool__;
         B_L_5ContG_methods.__str__ = (B_str (*) (B_L_5Cont))B_valueG_methods.__str__;
@@ -6937,7 +7409,9 @@ void B___init__ () {
         $register(&B_L_5ContG_methods);
     }
     {
-        B_L_6procG_methods.$GCINFO = "B_L_6proc";
+        memset(B_L_6procD_gcbm, 0xFF, sizeof(B_L_6procD_gcbm));
+        B_L_6procG_methods.$GCdescr = GC_make_descriptor(B_L_6procD_gcbm, GC_WORD_LEN(struct B_L_6proc));
+        B_L_6procG_methods.$name = "B_L_6proc";
         B_L_6procG_methods.$superclass = ($SuperG_class)&$procG_methods;
         B_L_6procG_methods.__bool__ = (B_bool (*) (B_L_6proc))B_valueG_methods.__bool__;
         B_L_6procG_methods.__str__ = (B_str (*) (B_L_6proc))B_valueG_methods.__str__;
@@ -6950,7 +7424,9 @@ void B___init__ () {
         $register(&B_L_6procG_methods);
     }
     {
-        B_WorldAuthG_methods.$GCINFO = "B_WorldAuth";
+        memset(B_WorldAuthD_gcbm, 0xFF, sizeof(B_WorldAuthD_gcbm));
+        B_WorldAuthG_methods.$GCdescr = GC_make_descriptor(B_WorldAuthD_gcbm, GC_WORD_LEN(struct B_WorldAuth));
+        B_WorldAuthG_methods.$name = "B_WorldAuth";
         B_WorldAuthG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         B_WorldAuthG_methods.__bool__ = (B_bool (*) (B_WorldAuth))B_valueG_methods.__bool__;
         B_WorldAuthG_methods.__str__ = (B_str (*) (B_WorldAuth))B_valueG_methods.__str__;
@@ -6961,7 +7437,9 @@ void B___init__ () {
         $register(&B_WorldAuthG_methods);
     }
     {
-        B_EnvG_methods.$GCINFO = "B_Env";
+        memset(B_EnvD_gcbm, 0xFF, sizeof(B_EnvD_gcbm));
+        B_EnvG_methods.$GCdescr = GC_make_descriptor(B_EnvD_gcbm, GC_WORD_LEN(struct B_Env));
+        B_EnvG_methods.$name = "B_Env";
         B_EnvG_methods.$superclass = ($SuperG_class)&$ActorG_methods;
         B_EnvG_methods.__bool__ = (B_bool (*) (B_Env))$ActorG_methods.__bool__;
         B_EnvG_methods.__str__ = (B_str (*) (B_Env))$ActorG_methods.__str__;
diff --git a/builtin/__builtin__.h b/builtin/__builtin__.h
index 457e7498b..39e928a05 100644
--- a/builtin/__builtin__.h
+++ b/builtin/__builtin__.h
@@ -1,3 +1,4 @@
+#include "gc/gc_typed.h"
 /*
 Building project in /Users/sydow/acton/builtin/ty
   Compiling __builtin__.act for release in stub mode
@@ -306,7 +307,8 @@ typedef struct B_ContainerD_bytes *B_ContainerD_bytes;
 typedef struct B_TimesD_bytes *B_TimesD_bytes;
 typedef struct B_HashableD_bytes *B_HashableD_bytes;
 struct B_valueG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_value);
@@ -319,8 +321,10 @@ struct B_valueG_class {
 struct B_value {
     struct B_valueG_class *$class;
 };
+extern GC_word B_valueD_gcbm[GC_BITMAP_SIZE(struct B_value)];
 struct B_objectG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_object);
@@ -333,8 +337,10 @@ struct B_objectG_class {
 struct B_object {
     struct B_objectG_class *$class;
 };
+extern GC_word B_objectD_gcbm[GC_BITMAP_SIZE(struct B_object)];
 struct B_atomG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_atom);
@@ -347,8 +353,10 @@ struct B_atomG_class {
 struct B_atom {
     struct B_atomG_class *$class;
 };
+extern GC_word B_atomD_gcbm[GC_BITMAP_SIZE(struct B_atom)];
 struct B_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_int, B_atom);
@@ -359,7 +367,8 @@ struct B_intG_class {
     B_str (*__repr__) (B_int);
 };
 struct B_i64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_i64, B_atom);
@@ -370,7 +379,8 @@ struct B_i64G_class {
     B_str (*__repr__) (B_i64);
 };
 struct B_i32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_i32, B_atom);
@@ -381,7 +391,8 @@ struct B_i32G_class {
     B_str (*__repr__) (B_i32);
 };
 struct B_i16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_i16, B_atom);
@@ -392,7 +403,8 @@ struct B_i16G_class {
     B_str (*__repr__) (B_i16);
 };
 struct B_u64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_u64, B_atom);
@@ -403,7 +415,8 @@ struct B_u64G_class {
     B_str (*__repr__) (B_u64);
 };
 struct B_u32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_u32, B_atom);
@@ -414,7 +427,8 @@ struct B_u32G_class {
     B_str (*__repr__) (B_u32);
 };
 struct B_u16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_u16, B_atom);
@@ -425,7 +439,8 @@ struct B_u16G_class {
     B_str (*__repr__) (B_u16);
 };
 struct B_floatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_float, B_atom);
@@ -436,7 +451,8 @@ struct B_floatG_class {
     B_str (*__repr__) (B_float);
 };
 struct B_boolG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_bool, B_value);
@@ -447,7 +463,8 @@ struct B_boolG_class {
     B_str (*__repr__) (B_bool);
 };
 struct B_sliceG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_slice, B_int, B_int, B_int);
@@ -458,7 +475,8 @@ struct B_sliceG_class {
     B_str (*__repr__) (B_slice);
 };
 struct B_listG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_list, B_Iterable, $WORD);
@@ -473,7 +491,8 @@ struct B_listG_class {
     $WORD (*pop) (B_list, B_int);
 };
 struct B_rangeG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_range, B_int, B_int, B_int);
@@ -484,7 +503,8 @@ struct B_rangeG_class {
     B_str (*__repr__) (B_range);
 };
 struct B_IteratorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Iterator);
@@ -498,8 +518,10 @@ struct B_IteratorG_class {
 struct B_Iterator {
     struct B_IteratorG_class *$class;
 };
+extern GC_word B_IteratorD_gcbm[GC_BITMAP_SIZE(struct B_Iterator)];
 struct B_IterableG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Iterable);
@@ -513,8 +535,10 @@ struct B_IterableG_class {
 struct B_Iterable {
     struct B_IterableG_class *$class;
 };
+extern GC_word B_IterableD_gcbm[GC_BITMAP_SIZE(struct B_Iterable)];
 struct B_strG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_str, B_value);
@@ -559,7 +583,8 @@ struct B_strG_class {
     B_str (*zfill) (B_str, B_int);
 };
 struct B_bytesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_bytes, B_Iterable, $WORD);
@@ -603,7 +628,8 @@ struct B_bytesG_class {
     B_bytes (*zfill) (B_bytes, B_int);
 };
 struct B_bytearrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_bytearray, B_bytes);
@@ -648,7 +674,8 @@ struct B_bytearrayG_class {
 };
 /*
 struct B_MsgG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Msg);
@@ -661,9 +688,11 @@ struct B_MsgG_class {
 struct B_Msg {
     struct B_MsgG_class *$class;
 };
+extern GC_word B_MsgD_gcbm[GC_BITMAP_SIZE(struct B_Msg)];
 */
 struct B_BaseExceptionG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_BaseException, B_str);
@@ -677,8 +706,10 @@ struct B_BaseException {
     struct B_BaseExceptionG_class *$class;
     B_str error_message;
 };
+extern GC_word B_BaseExceptionD_gcbm[GC_BITMAP_SIZE(struct B_BaseException)];
 struct B_SystemExitG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_SystemExit, B_str);
@@ -692,8 +723,10 @@ struct B_SystemExit {
     struct B_SystemExitG_class *$class;
     B_str error_message;
 };
+extern GC_word B_SystemExitD_gcbm[GC_BITMAP_SIZE(struct B_SystemExit)];
 struct B_KeyboardInterruptG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_KeyboardInterrupt, B_str);
@@ -707,8 +740,10 @@ struct B_KeyboardInterrupt {
     struct B_KeyboardInterruptG_class *$class;
     B_str error_message;
 };
+extern GC_word B_KeyboardInterruptD_gcbm[GC_BITMAP_SIZE(struct B_KeyboardInterrupt)];
 struct B_ExceptionG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Exception, B_str);
@@ -722,8 +757,10 @@ struct B_Exception {
     struct B_ExceptionG_class *$class;
     B_str error_message;
 };
+extern GC_word B_ExceptionD_gcbm[GC_BITMAP_SIZE(struct B_Exception)];
 struct B_AssertionErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_AssertionError, B_str);
@@ -737,8 +774,10 @@ struct B_AssertionError {
     struct B_AssertionErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_AssertionErrorD_gcbm[GC_BITMAP_SIZE(struct B_AssertionError)];
 struct B_LookupErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LookupError, B_str);
@@ -752,8 +791,10 @@ struct B_LookupError {
     struct B_LookupErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_LookupErrorD_gcbm[GC_BITMAP_SIZE(struct B_LookupError)];
 struct B_IndexErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IndexError, B_str);
@@ -767,8 +808,10 @@ struct B_IndexError {
     struct B_IndexErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_IndexErrorD_gcbm[GC_BITMAP_SIZE(struct B_IndexError)];
 struct B_KeyErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_KeyError, B_str);
@@ -782,8 +825,10 @@ struct B_KeyError {
     struct B_KeyErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_KeyErrorD_gcbm[GC_BITMAP_SIZE(struct B_KeyError)];
 struct B_MemoryErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MemoryError, B_str);
@@ -797,8 +842,10 @@ struct B_MemoryError {
     struct B_MemoryErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_MemoryErrorD_gcbm[GC_BITMAP_SIZE(struct B_MemoryError)];
 struct B_OSErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OSError, B_str);
@@ -812,8 +859,10 @@ struct B_OSError {
     struct B_OSErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_OSErrorD_gcbm[GC_BITMAP_SIZE(struct B_OSError)];
 struct B_RuntimeErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_RuntimeError, B_str);
@@ -827,8 +876,10 @@ struct B_RuntimeError {
     struct B_RuntimeErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_RuntimeErrorD_gcbm[GC_BITMAP_SIZE(struct B_RuntimeError)];
 struct B_NotImplementedErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_NotImplementedError, B_str);
@@ -842,8 +893,10 @@ struct B_NotImplementedError {
     struct B_NotImplementedErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_NotImplementedErrorD_gcbm[GC_BITMAP_SIZE(struct B_NotImplementedError)];
 struct B_ValueErrorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_ValueError, B_str);
@@ -857,8 +910,10 @@ struct B_ValueError {
     struct B_ValueErrorG_class *$class;
     B_str error_message;
 };
+extern GC_word B_ValueErrorD_gcbm[GC_BITMAP_SIZE(struct B_ValueError)];
 struct B_IdentityG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Identity);
@@ -873,8 +928,10 @@ struct B_IdentityG_class {
 struct B_Identity {
     struct B_IdentityG_class *$class;
 };
+extern GC_word B_IdentityD_gcbm[GC_BITMAP_SIZE(struct B_Identity)];
 struct B_EqG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Eq);
@@ -889,8 +946,10 @@ struct B_EqG_class {
 struct B_Eq {
     struct B_EqG_class *$class;
 };
+extern GC_word B_EqD_gcbm[GC_BITMAP_SIZE(struct B_Eq)];
 struct B_OrdG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Ord);
@@ -909,8 +968,10 @@ struct B_OrdG_class {
 struct B_Ord {
     struct B_OrdG_class *$class;
 };
+extern GC_word B_OrdD_gcbm[GC_BITMAP_SIZE(struct B_Ord)];
 struct B_LogicalG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Logical);
@@ -929,8 +990,10 @@ struct B_LogicalG_class {
 struct B_Logical {
     struct B_LogicalG_class *$class;
 };
+extern GC_word B_LogicalD_gcbm[GC_BITMAP_SIZE(struct B_Logical)];
 struct B_PlusG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Plus);
@@ -945,8 +1008,10 @@ struct B_PlusG_class {
 struct B_Plus {
     struct B_PlusG_class *$class;
 };
+extern GC_word B_PlusD_gcbm[GC_BITMAP_SIZE(struct B_Plus)];
 struct B_MinusG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Minus);
@@ -961,8 +1026,10 @@ struct B_MinusG_class {
 struct B_Minus {
     struct B_MinusG_class *$class;
 };
+extern GC_word B_MinusD_gcbm[GC_BITMAP_SIZE(struct B_Minus)];
 struct B_TimesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Times);
@@ -979,8 +1046,10 @@ struct B_TimesG_class {
 struct B_Times {
     struct B_TimesG_class *$class;
 };
+extern GC_word B_TimesD_gcbm[GC_BITMAP_SIZE(struct B_Times)];
 struct B_DivG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Div);
@@ -995,8 +1064,10 @@ struct B_DivG_class {
 struct B_Div {
     struct B_DivG_class *$class;
 };
+extern GC_word B_DivD_gcbm[GC_BITMAP_SIZE(struct B_Div)];
 struct B_HashableG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Hashable);
@@ -1012,8 +1083,10 @@ struct B_HashableG_class {
 struct B_Hashable {
     struct B_HashableG_class *$class;
 };
+extern GC_word B_HashableD_gcbm[GC_BITMAP_SIZE(struct B_Hashable)];
 struct B_complexG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_complex, B_Number, $WORD);
@@ -1024,7 +1097,8 @@ struct B_complexG_class {
     B_str (*__repr__) (B_complex);
 };
 struct B_dictG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_dict, B_Hashable, B_Iterable, $WORD);
@@ -1035,7 +1109,8 @@ struct B_dictG_class {
     B_str (*__repr__) (B_dict);
 };
 struct B_setG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_set, B_Hashable, B_Iterable, $WORD);
@@ -1046,7 +1121,8 @@ struct B_setG_class {
     B_str (*__repr__) (B_set);
 };
 struct B_NumberG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Number, B_Minus);
@@ -1074,8 +1150,10 @@ struct B_Number {
     struct B_NumberG_class *$class;
     B_Minus W_Minus;
 };
+extern GC_word B_NumberD_gcbm[GC_BITMAP_SIZE(struct B_Number)];
 struct B_MinusD_NumberG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_Number, B_Number);
@@ -1091,8 +1169,10 @@ struct B_MinusD_Number {
     struct B_MinusD_NumberG_class *$class;
     B_Number W_Number;
 };
+extern GC_word B_MinusD_NumberD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Number)];
 struct B_RealG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Real, B_Minus);
@@ -1125,8 +1205,10 @@ struct B_Real {
     struct B_RealG_class *$class;
     B_Minus W_Minus;
 };
+extern GC_word B_RealD_gcbm[GC_BITMAP_SIZE(struct B_Real)];
 struct B_MinusD_RealG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_Real, B_Real);
@@ -1143,8 +1225,10 @@ struct B_MinusD_Real {
     B_Number W_Number;
     B_Real W_Real;
 };
+extern GC_word B_MinusD_RealD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Real)];
 struct B_RealFloatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_RealFloat, B_Minus);
@@ -1177,8 +1261,10 @@ struct B_RealFloat {
     struct B_RealFloatG_class *$class;
     B_Minus W_Minus;
 };
+extern GC_word B_RealFloatD_gcbm[GC_BITMAP_SIZE(struct B_RealFloat)];
 struct B_MinusD_RealFloatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_RealFloat, B_RealFloat);
@@ -1196,8 +1282,10 @@ struct B_MinusD_RealFloat {
     B_Real W_Real;
     B_RealFloat W_RealFloat;
 };
+extern GC_word B_MinusD_RealFloatD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_RealFloat)];
 struct B_RationalG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Rational, B_Minus);
@@ -1232,8 +1320,10 @@ struct B_Rational {
     struct B_RationalG_class *$class;
     B_Minus W_Minus;
 };
+extern GC_word B_RationalD_gcbm[GC_BITMAP_SIZE(struct B_Rational)];
 struct B_MinusD_RationalG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_Rational, B_Rational);
@@ -1251,8 +1341,10 @@ struct B_MinusD_Rational {
     B_Real W_Real;
     B_Rational W_Rational;
 };
+extern GC_word B_MinusD_RationalD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Rational)];
 struct B_IntegralG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Integral, B_Minus, B_Logical);
@@ -1300,8 +1392,10 @@ struct B_Integral {
     B_Minus W_Minus;
     B_Logical W_Logical;
 };
+extern GC_word B_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_Integral)];
 struct B_MinusD_IntegralG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_Integral, B_Integral);
@@ -1320,8 +1414,10 @@ struct B_MinusD_Integral {
     B_Rational W_Rational;
     B_Integral W_Integral;
 };
+extern GC_word B_MinusD_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Integral)];
 struct B_LogicalD_IntegralG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_Integral, B_Integral);
@@ -1341,8 +1437,10 @@ struct B_LogicalD_Integral {
     struct B_LogicalD_IntegralG_class *$class;
     B_Integral W_Integral;
 };
+extern GC_word B_LogicalD_IntegralD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_Integral)];
 struct B_HashableD_boolG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_bool);
@@ -1358,8 +1456,10 @@ struct B_HashableD_boolG_class {
 struct B_HashableD_bool {
     struct B_HashableD_boolG_class *$class;
 };
+extern GC_word B_HashableD_boolD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_bool)];
 struct B_IntegralD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IntegralD_int);
@@ -1407,8 +1507,10 @@ struct B_IntegralD_int {
     B_Minus W_Minus;
     B_Logical W_Logical;
 };
+extern GC_word B_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_int)];
 struct B_MinusD_IntegralD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_IntegralD_int, B_Integral);
@@ -1427,8 +1529,10 @@ struct B_MinusD_IntegralD_int {
     B_Rational W_Rational;
     B_Integral W_Integral;
 };
+extern GC_word B_MinusD_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_int)];
 struct B_LogicalD_IntegralD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_IntegralD_int, B_Integral);
@@ -1448,8 +1552,10 @@ struct B_LogicalD_IntegralD_int {
     struct B_LogicalD_IntegralD_intG_class *$class;
     B_Integral W_Integral;
 };
+extern GC_word B_LogicalD_IntegralD_intD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_int)];
 struct B_DivD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_int);
@@ -1464,8 +1570,10 @@ struct B_DivD_intG_class {
 struct B_DivD_int {
     struct B_DivD_intG_class *$class;
 };
+extern GC_word B_DivD_intD_gcbm[GC_BITMAP_SIZE(struct B_DivD_int)];
 struct B_OrdD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_int);
@@ -1484,8 +1592,10 @@ struct B_OrdD_intG_class {
 struct B_OrdD_int {
     struct B_OrdD_intG_class *$class;
 };
+extern GC_word B_OrdD_intD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_int)];
 struct B_HashableD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_int);
@@ -1501,8 +1611,10 @@ struct B_HashableD_intG_class {
 struct B_HashableD_int {
     struct B_HashableD_intG_class *$class;
 };
+extern GC_word B_HashableD_intD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_int)];
 struct B_IntegralD_i64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IntegralD_i64);
@@ -1550,8 +1662,10 @@ struct B_IntegralD_i64 {
     B_Minus W_Minus;
     B_Logical W_Logical;
 };
+extern GC_word B_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i64)];
 struct B_MinusD_IntegralD_i64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_IntegralD_i64, B_Integral);
@@ -1570,8 +1684,10 @@ struct B_MinusD_IntegralD_i64 {
     B_Rational W_Rational;
     B_Integral W_Integral;
 };
+extern GC_word B_MinusD_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i64)];
 struct B_LogicalD_IntegralD_i64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_IntegralD_i64, B_Integral);
@@ -1591,8 +1707,10 @@ struct B_LogicalD_IntegralD_i64 {
     struct B_LogicalD_IntegralD_i64G_class *$class;
     B_Integral W_Integral;
 };
+extern GC_word B_LogicalD_IntegralD_i64D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i64)];
 struct B_DivD_i64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_i64);
@@ -1607,8 +1725,10 @@ struct B_DivD_i64G_class {
 struct B_DivD_i64 {
     struct B_DivD_i64G_class *$class;
 };
+extern GC_word B_DivD_i64D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i64)];
 struct B_OrdD_i64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_i64);
@@ -1627,8 +1747,10 @@ struct B_OrdD_i64G_class {
 struct B_OrdD_i64 {
     struct B_OrdD_i64G_class *$class;
 };
+extern GC_word B_OrdD_i64D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i64)];
 struct B_HashableD_i64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_i64);
@@ -1644,6 +1766,7 @@ struct B_HashableD_i64G_class {
 struct B_HashableD_i64 {
     struct B_HashableD_i64G_class *$class;
 };
+extern GC_word B_HashableD_i64D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i64)];
 
 
 
@@ -1652,7 +1775,8 @@ struct B_HashableD_i64 {
 
 
 struct B_IntegralD_i32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IntegralD_i32);
@@ -1700,8 +1824,10 @@ struct B_IntegralD_i32 {
     B_Minus W_Minus;
     B_Logical W_Logical;
 };
+extern GC_word B_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i32)];
 struct B_MinusD_IntegralD_i32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_IntegralD_i32, B_Integral);
@@ -1720,8 +1846,10 @@ struct B_MinusD_IntegralD_i32 {
     B_Rational W_Rational;
     B_Integral W_Integral;
 };
+extern GC_word B_MinusD_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i32)];
 struct B_LogicalD_IntegralD_i32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_IntegralD_i32, B_Integral);
@@ -1741,8 +1869,10 @@ struct B_LogicalD_IntegralD_i32 {
     struct B_LogicalD_IntegralD_i32G_class *$class;
     B_Integral W_Integral;
 };
+extern GC_word B_LogicalD_IntegralD_i32D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i32)];
 struct B_DivD_i32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_i32);
@@ -1757,8 +1887,10 @@ struct B_DivD_i32G_class {
 struct B_DivD_i32 {
     struct B_DivD_i32G_class *$class;
 };
+extern GC_word B_DivD_i32D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i32)];
 struct B_OrdD_i32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_i32);
@@ -1777,8 +1909,10 @@ struct B_OrdD_i32G_class {
 struct B_OrdD_i32 {
     struct B_OrdD_i32G_class *$class;
 };
+extern GC_word B_OrdD_i32D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i32)];
 struct B_HashableD_i32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_i32);
@@ -1794,6 +1928,7 @@ struct B_HashableD_i32G_class {
 struct B_HashableD_i32 {
     struct B_HashableD_i32G_class *$class;
 };
+extern GC_word B_HashableD_i32D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i32)];
 
 
 
@@ -1802,7 +1937,8 @@ struct B_HashableD_i32 {
 
 
 struct B_IntegralD_i16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IntegralD_i16);
@@ -1850,8 +1986,10 @@ struct B_IntegralD_i16 {
     B_Minus W_Minus;
     B_Logical W_Logical;
 };
+extern GC_word B_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_i16)];
 struct B_MinusD_IntegralD_i16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_IntegralD_i16, B_Integral);
@@ -1870,8 +2008,10 @@ struct B_MinusD_IntegralD_i16 {
     B_Rational W_Rational;
     B_Integral W_Integral;
 };
+extern GC_word B_MinusD_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_i16)];
 struct B_LogicalD_IntegralD_i16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_IntegralD_i16, B_Integral);
@@ -1891,8 +2031,10 @@ struct B_LogicalD_IntegralD_i16 {
     struct B_LogicalD_IntegralD_i16G_class *$class;
     B_Integral W_Integral;
 };
+extern GC_word B_LogicalD_IntegralD_i16D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_i16)];
 struct B_DivD_i16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_i16);
@@ -1907,8 +2049,10 @@ struct B_DivD_i16G_class {
 struct B_DivD_i16 {
     struct B_DivD_i16G_class *$class;
 };
+extern GC_word B_DivD_i16D_gcbm[GC_BITMAP_SIZE(struct B_DivD_i16)];
 struct B_OrdD_i16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_i16);
@@ -1927,8 +2071,10 @@ struct B_OrdD_i16G_class {
 struct B_OrdD_i16 {
     struct B_OrdD_i16G_class *$class;
 };
+extern GC_word B_OrdD_i16D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_i16)];
 struct B_HashableD_i16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_i16);
@@ -1944,6 +2090,7 @@ struct B_HashableD_i16G_class {
 struct B_HashableD_i16 {
     struct B_HashableD_i16G_class *$class;
 };
+extern GC_word B_HashableD_i16D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_i16)];
 
 
 
@@ -1952,7 +2099,8 @@ struct B_HashableD_i16 {
 
 
 struct B_IntegralD_u64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IntegralD_u64);
@@ -2000,8 +2148,10 @@ struct B_IntegralD_u64 {
     B_Minus W_Minus;
     B_Logical W_Logical;
 };
+extern GC_word B_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u64)];
 struct B_MinusD_IntegralD_u64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_IntegralD_u64, B_Integral);
@@ -2020,8 +2170,10 @@ struct B_MinusD_IntegralD_u64 {
     B_Rational W_Rational;
     B_Integral W_Integral;
 };
+extern GC_word B_MinusD_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u64)];
 struct B_LogicalD_IntegralD_u64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_IntegralD_u64, B_Integral);
@@ -2041,8 +2193,10 @@ struct B_LogicalD_IntegralD_u64 {
     struct B_LogicalD_IntegralD_u64G_class *$class;
     B_Integral W_Integral;
 };
+extern GC_word B_LogicalD_IntegralD_u64D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u64)];
 struct B_DivD_u64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_u64);
@@ -2057,8 +2211,10 @@ struct B_DivD_u64G_class {
 struct B_DivD_u64 {
     struct B_DivD_u64G_class *$class;
 };
+extern GC_word B_DivD_u64D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u64)];
 struct B_OrdD_u64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_u64);
@@ -2077,8 +2233,10 @@ struct B_OrdD_u64G_class {
 struct B_OrdD_u64 {
     struct B_OrdD_u64G_class *$class;
 };
+extern GC_word B_OrdD_u64D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u64)];
 struct B_HashableD_u64G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_u64);
@@ -2094,6 +2252,7 @@ struct B_HashableD_u64G_class {
 struct B_HashableD_u64 {
     struct B_HashableD_u64G_class *$class;
 };
+extern GC_word B_HashableD_u64D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u64)];
 
 
 
@@ -2101,7 +2260,8 @@ struct B_HashableD_u64 {
 
 
 struct B_IntegralD_u32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IntegralD_u32);
@@ -2149,8 +2309,10 @@ struct B_IntegralD_u32 {
     B_Minus W_Minus;
     B_Logical W_Logical;
 };
+extern GC_word B_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u32)];
 struct B_MinusD_IntegralD_u32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_IntegralD_u32, B_Integral);
@@ -2169,8 +2331,10 @@ struct B_MinusD_IntegralD_u32 {
     B_Rational W_Rational;
     B_Integral W_Integral;
 };
+extern GC_word B_MinusD_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u32)];
 struct B_LogicalD_IntegralD_u32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_IntegralD_u32, B_Integral);
@@ -2190,8 +2354,10 @@ struct B_LogicalD_IntegralD_u32 {
     struct B_LogicalD_IntegralD_u32G_class *$class;
     B_Integral W_Integral;
 };
+extern GC_word B_LogicalD_IntegralD_u32D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u32)];
 struct B_DivD_u32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_u32);
@@ -2206,8 +2372,10 @@ struct B_DivD_u32G_class {
 struct B_DivD_u32 {
     struct B_DivD_u32G_class *$class;
 };
+extern GC_word B_DivD_u32D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u32)];
 struct B_OrdD_u32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_u32);
@@ -2226,8 +2394,10 @@ struct B_OrdD_u32G_class {
 struct B_OrdD_u32 {
     struct B_OrdD_u32G_class *$class;
 };
+extern GC_word B_OrdD_u32D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u32)];
 struct B_HashableD_u32G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_u32);
@@ -2243,6 +2413,7 @@ struct B_HashableD_u32G_class {
 struct B_HashableD_u32 {
     struct B_HashableD_u32G_class *$class;
 };
+extern GC_word B_HashableD_u32D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u32)];
 
 
 
@@ -2250,7 +2421,8 @@ struct B_HashableD_u32 {
 
 
 struct B_IntegralD_u16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IntegralD_u16);
@@ -2298,8 +2470,10 @@ struct B_IntegralD_u16 {
     B_Minus W_Minus;
     B_Logical W_Logical;
 };
+extern GC_word B_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_IntegralD_u16)];
 struct B_MinusD_IntegralD_u16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_IntegralD_u16, B_Integral);
@@ -2318,8 +2492,10 @@ struct B_MinusD_IntegralD_u16 {
     B_Rational W_Rational;
     B_Integral W_Integral;
 };
+extern GC_word B_MinusD_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_MinusD_IntegralD_u16)];
 struct B_LogicalD_IntegralD_u16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_IntegralD_u16, B_Integral);
@@ -2339,8 +2515,10 @@ struct B_LogicalD_IntegralD_u16 {
     struct B_LogicalD_IntegralD_u16G_class *$class;
     B_Integral W_Integral;
 };
+extern GC_word B_LogicalD_IntegralD_u16D_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_IntegralD_u16)];
 struct B_DivD_u16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_u16);
@@ -2355,8 +2533,10 @@ struct B_DivD_u16G_class {
 struct B_DivD_u16 {
     struct B_DivD_u16G_class *$class;
 };
+extern GC_word B_DivD_u16D_gcbm[GC_BITMAP_SIZE(struct B_DivD_u16)];
 struct B_OrdD_u16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_u16);
@@ -2375,8 +2555,10 @@ struct B_OrdD_u16G_class {
 struct B_OrdD_u16 {
     struct B_OrdD_u16G_class *$class;
 };
+extern GC_word B_OrdD_u16D_gcbm[GC_BITMAP_SIZE(struct B_OrdD_u16)];
 struct B_HashableD_u16G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_u16);
@@ -2392,6 +2574,7 @@ struct B_HashableD_u16G_class {
 struct B_HashableD_u16 {
     struct B_HashableD_u16G_class *$class;
 };
+extern GC_word B_HashableD_u16D_gcbm[GC_BITMAP_SIZE(struct B_HashableD_u16)];
 
 
 
@@ -2400,7 +2583,8 @@ struct B_HashableD_u16 {
 
 
 struct B_RealFloatD_floatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_RealFloatD_float);
@@ -2433,8 +2617,10 @@ struct B_RealFloatD_float {
     struct B_RealFloatD_floatG_class *$class;
     B_Minus W_Minus;
 };
+extern GC_word B_RealFloatD_floatD_gcbm[GC_BITMAP_SIZE(struct B_RealFloatD_float)];
 struct B_MinusD_RealFloatD_floatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_RealFloatD_float, B_RealFloat);
@@ -2452,8 +2638,10 @@ struct B_MinusD_RealFloatD_float {
     B_Real W_Real;
     B_RealFloat W_RealFloat;
 };
+extern GC_word B_MinusD_RealFloatD_floatD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_RealFloatD_float)];
 struct B_DivD_floatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_float);
@@ -2468,8 +2656,10 @@ struct B_DivD_floatG_class {
 struct B_DivD_float {
     struct B_DivD_floatG_class *$class;
 };
+extern GC_word B_DivD_floatD_gcbm[GC_BITMAP_SIZE(struct B_DivD_float)];
 struct B_OrdD_floatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_float);
@@ -2488,8 +2678,10 @@ struct B_OrdD_floatG_class {
 struct B_OrdD_float {
     struct B_OrdD_floatG_class *$class;
 };
+extern GC_word B_OrdD_floatD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_float)];
 struct B_HashableD_floatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_float);
@@ -2505,8 +2697,10 @@ struct B_HashableD_floatG_class {
 struct B_HashableD_float {
     struct B_HashableD_floatG_class *$class;
 };
+extern GC_word B_HashableD_floatD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_float)];
 struct B_NumberD_complexG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_NumberD_complex);
@@ -2534,8 +2728,10 @@ struct B_NumberD_complex {
     struct B_NumberD_complexG_class *$class;
     B_Minus W_Minus;
 };
+extern GC_word B_NumberD_complexD_gcbm[GC_BITMAP_SIZE(struct B_NumberD_complex)];
 struct B_MinusD_NumberD_complexG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_NumberD_complex, B_Number);
@@ -2551,8 +2747,10 @@ struct B_MinusD_NumberD_complex {
     struct B_MinusD_NumberD_complexG_class *$class;
     B_Number W_Number;
 };
+extern GC_word B_MinusD_NumberD_complexD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_NumberD_complex)];
 struct B_DivD_complexG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_DivD_complex);
@@ -2567,8 +2765,10 @@ struct B_DivD_complexG_class {
 struct B_DivD_complex {
     struct B_DivD_complexG_class *$class;
 };
+extern GC_word B_DivD_complexD_gcbm[GC_BITMAP_SIZE(struct B_DivD_complex)];
 struct B_EqD_complexG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_EqD_complex);
@@ -2583,8 +2783,10 @@ struct B_EqD_complexG_class {
 struct B_EqD_complex {
     struct B_EqD_complexG_class *$class;
 };
+extern GC_word B_EqD_complexD_gcbm[GC_BITMAP_SIZE(struct B_EqD_complex)];
 struct B_HashableD_complexG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_complex);
@@ -2600,8 +2802,10 @@ struct B_HashableD_complexG_class {
 struct B_HashableD_complex {
     struct B_HashableD_complexG_class *$class;
 };
+extern GC_word B_HashableD_complexD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_complex)];
 struct B_IndexedG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Indexed, B_Eq);
@@ -2618,8 +2822,10 @@ struct B_Indexed {
     struct B_IndexedG_class *$class;
     B_Eq W_EqD_AD_Indexed;
 };
+extern GC_word B_IndexedD_gcbm[GC_BITMAP_SIZE(struct B_Indexed)];
 struct B_SliceableG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Sliceable);
@@ -2639,8 +2845,10 @@ struct B_Sliceable {
     struct B_SliceableG_class *$class;
     B_Eq W_EqD_AD_Indexed;
 };
+extern GC_word B_SliceableD_gcbm[GC_BITMAP_SIZE(struct B_Sliceable)];
 struct B_CollectionG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Collection);
@@ -2656,8 +2864,10 @@ struct B_CollectionG_class {
 struct B_Collection {
     struct B_CollectionG_class *$class;
 };
+extern GC_word B_CollectionD_gcbm[GC_BITMAP_SIZE(struct B_Collection)];
 struct B_ContainerG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Container, B_Eq);
@@ -2676,8 +2886,10 @@ struct B_Container {
     struct B_ContainerG_class *$class;
     B_Eq W_EqD_AD_Container;
 };
+extern GC_word B_ContainerD_gcbm[GC_BITMAP_SIZE(struct B_Container)];
 struct B_SequenceG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Sequence, B_Collection, B_Times);
@@ -2703,8 +2915,10 @@ struct B_Sequence {
     B_Collection W_Collection;
     B_Times W_Times;
 };
+extern GC_word B_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_Sequence)];
 struct B_CollectionD_SequenceG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_CollectionD_Sequence, B_Sequence);
@@ -2721,8 +2935,10 @@ struct B_CollectionD_Sequence {
     struct B_CollectionD_SequenceG_class *$class;
     B_Sequence W_Sequence;
 };
+extern GC_word B_CollectionD_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_Sequence)];
 struct B_TimesD_SequenceG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_TimesD_Sequence, B_Sequence);
@@ -2740,8 +2956,10 @@ struct B_TimesD_Sequence {
     struct B_TimesD_SequenceG_class *$class;
     B_Sequence W_Sequence;
 };
+extern GC_word B_TimesD_SequenceD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_Sequence)];
 struct B_MappingG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Mapping, B_Eq, B_Indexed);
@@ -2769,8 +2987,10 @@ struct B_Mapping {
     B_Eq W_EqD_AD_Mapping;
     B_Indexed W_Indexed;
 };
+extern GC_word B_MappingD_gcbm[GC_BITMAP_SIZE(struct B_Mapping)];
 struct B_IndexedD_MappingG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IndexedD_Mapping, B_Eq, B_Mapping);
@@ -2789,8 +3009,10 @@ struct B_IndexedD_Mapping {
     B_Eq W_EqD_AD_Mapping;
     B_Mapping W_Mapping;
 };
+extern GC_word B_IndexedD_MappingD_gcbm[GC_BITMAP_SIZE(struct B_IndexedD_Mapping)];
 struct B_SetG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Set, B_Eq, B_Ord, B_Logical, B_Minus);
@@ -2817,8 +3039,10 @@ struct B_Set {
     B_Logical W_Logical;
     B_Minus W_Minus;
 };
+extern GC_word B_SetD_gcbm[GC_BITMAP_SIZE(struct B_Set)];
 struct B_OrdD_SetG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_Set, B_Eq, B_Set);
@@ -2839,8 +3063,10 @@ struct B_OrdD_Set {
     B_Eq W_EqD_AD_Set;
     B_Set W_Set;
 };
+extern GC_word B_OrdD_SetD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_Set)];
 struct B_LogicalD_SetG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_Set, B_Eq, B_Set);
@@ -2861,8 +3087,10 @@ struct B_LogicalD_Set {
     B_Eq W_EqD_AD_Set;
     B_Set W_Set;
 };
+extern GC_word B_LogicalD_SetD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_Set)];
 struct B_MinusD_SetG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_Set, B_Eq, B_Set);
@@ -2879,8 +3107,10 @@ struct B_MinusD_Set {
     B_Eq W_EqD_AD_Set;
     B_Set W_Set;
 };
+extern GC_word B_MinusD_SetD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_Set)];
 struct B_SequenceD_listG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_SequenceD_list);
@@ -2906,8 +3136,10 @@ struct B_SequenceD_list {
     B_Collection W_Collection;
     B_Times W_Times;
 };
+extern GC_word B_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_SequenceD_list)];
 struct B_CollectionD_SequenceD_listG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_CollectionD_SequenceD_list, B_Sequence);
@@ -2924,8 +3156,10 @@ struct B_CollectionD_SequenceD_list {
     struct B_CollectionD_SequenceD_listG_class *$class;
     B_Sequence W_Sequence;
 };
+extern GC_word B_CollectionD_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_SequenceD_list)];
 struct B_TimesD_SequenceD_listG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_TimesD_SequenceD_list, B_Sequence);
@@ -2943,8 +3177,10 @@ struct B_TimesD_SequenceD_list {
     struct B_TimesD_SequenceD_listG_class *$class;
     B_Sequence W_Sequence;
 };
+extern GC_word B_TimesD_SequenceD_listD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_SequenceD_list)];
 struct B_ContainerD_listG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_ContainerD_list, B_Eq);
@@ -2964,8 +3200,10 @@ struct B_ContainerD_list {
     B_Eq W_EqD_AD_Container;
     B_Eq W_EqD_AD_ContainerD_list;
 };
+extern GC_word B_ContainerD_listD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_list)];
 struct B_OrdD_listG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_list, B_Ord);
@@ -2985,8 +3223,10 @@ struct B_OrdD_list {
     struct B_OrdD_listG_class *$class;
     B_Ord W_OrdD_AD_OrdD_list;
 };
+extern GC_word B_OrdD_listD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_list)];
 struct B_MappingD_dictG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MappingD_dict, B_Hashable);
@@ -3015,8 +3255,10 @@ struct B_MappingD_dict {
     B_Indexed W_Indexed;
     B_Hashable W_HashableD_AD_MappingD_dict;
 };
+extern GC_word B_MappingD_dictD_gcbm[GC_BITMAP_SIZE(struct B_MappingD_dict)];
 struct B_IndexedD_MappingD_dictG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IndexedD_MappingD_dict, B_Hashable, B_Mapping);
@@ -3036,8 +3278,10 @@ struct B_IndexedD_MappingD_dict {
     B_Mapping W_Mapping;
     B_Hashable W_HashableD_AD_MappingD_dict;
 };
+extern GC_word B_IndexedD_MappingD_dictD_gcbm[GC_BITMAP_SIZE(struct B_IndexedD_MappingD_dict)];
 struct B_OrdD_dictG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_dict, B_Hashable, B_Eq);
@@ -3058,8 +3302,10 @@ struct B_OrdD_dict {
     B_Hashable W_HashableD_AD_OrdD_dict;
     B_Eq W_EqD_BD_OrdD_dict;
 };
+extern GC_word B_OrdD_dictD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_dict)];
 struct B_SetD_setG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_SetD_set, B_Hashable);
@@ -3087,8 +3333,10 @@ struct B_SetD_set {
     B_Minus W_Minus;
     B_Hashable W_HashableD_AD_SetD_set;
 };
+extern GC_word B_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_SetD_set)];
 struct B_OrdD_SetD_setG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_SetD_set, B_Hashable, B_Set);
@@ -3110,8 +3358,10 @@ struct B_OrdD_SetD_set {
     B_Set W_Set;
     B_Hashable W_HashableD_AD_SetD_set;
 };
+extern GC_word B_OrdD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_SetD_set)];
 struct B_LogicalD_SetD_setG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_LogicalD_SetD_set, B_Hashable, B_Set);
@@ -3133,8 +3383,10 @@ struct B_LogicalD_SetD_set {
     B_Set W_Set;
     B_Hashable W_HashableD_AD_SetD_set;
 };
+extern GC_word B_LogicalD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_LogicalD_SetD_set)];
 struct B_MinusD_SetD_setG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_MinusD_SetD_set, B_Hashable, B_Set);
@@ -3152,8 +3404,10 @@ struct B_MinusD_SetD_set {
     B_Set W_Set;
     B_Hashable W_HashableD_AD_SetD_set;
 };
+extern GC_word B_MinusD_SetD_setD_gcbm[GC_BITMAP_SIZE(struct B_MinusD_SetD_set)];
 struct B_IterableD_IteratorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IterableD_Iterator);
@@ -3167,8 +3421,10 @@ struct B_IterableD_IteratorG_class {
 struct B_IterableD_Iterator {
     struct B_IterableD_IteratorG_class *$class;
 };
+extern GC_word B_IterableD_IteratorD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_Iterator)];
 struct B_IterableD_rangeG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_IterableD_range);
@@ -3182,8 +3438,10 @@ struct B_IterableD_rangeG_class {
 struct B_IterableD_range {
     struct B_IterableD_rangeG_class *$class;
 };
+extern GC_word B_IterableD_rangeD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_range)];
 struct B_OrdD_strG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_str);
@@ -3202,8 +3460,10 @@ struct B_OrdD_strG_class {
 struct B_OrdD_str {
     struct B_OrdD_strG_class *$class;
 };
+extern GC_word B_OrdD_strD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_str)];
 struct B_ContainerD_strG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_ContainerD_str);
@@ -3222,8 +3482,10 @@ struct B_ContainerD_str {
     struct B_ContainerD_strG_class *$class;
     B_Eq W_EqD_AD_Container;
 };
+extern GC_word B_ContainerD_strD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_str)];
 struct B_SliceableD_strG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_SliceableD_str);
@@ -3243,8 +3505,10 @@ struct B_SliceableD_str {
     struct B_SliceableD_strG_class *$class;
     B_Eq W_EqD_AD_Indexed;
 };
+extern GC_word B_SliceableD_strD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_str)];
 struct B_TimesD_strG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_TimesD_str);
@@ -3261,8 +3525,10 @@ struct B_TimesD_strG_class {
 struct B_TimesD_str {
     struct B_TimesD_strG_class *$class;
 };
+extern GC_word B_TimesD_strD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_str)];
 struct B_HashableD_strG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_str);
@@ -3278,8 +3544,10 @@ struct B_HashableD_strG_class {
 struct B_HashableD_str {
     struct B_HashableD_strG_class *$class;
 };
+extern GC_word B_HashableD_strD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_str)];
 struct B_OrdD_bytearrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_bytearray);
@@ -3298,8 +3566,10 @@ struct B_OrdD_bytearrayG_class {
 struct B_OrdD_bytearray {
     struct B_OrdD_bytearrayG_class *$class;
 };
+extern GC_word B_OrdD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_bytearray)];
 struct B_SequenceD_bytearrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_SequenceD_bytearray);
@@ -3325,8 +3595,10 @@ struct B_SequenceD_bytearray {
     B_Collection W_Collection;
     B_Times W_Times;
 };
+extern GC_word B_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_SequenceD_bytearray)];
 struct B_CollectionD_SequenceD_bytearrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_CollectionD_SequenceD_bytearray, B_Sequence);
@@ -3343,8 +3615,10 @@ struct B_CollectionD_SequenceD_bytearray {
     struct B_CollectionD_SequenceD_bytearrayG_class *$class;
     B_Sequence W_Sequence;
 };
+extern GC_word B_CollectionD_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_CollectionD_SequenceD_bytearray)];
 struct B_TimesD_SequenceD_bytearrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_TimesD_SequenceD_bytearray, B_Sequence);
@@ -3362,8 +3636,10 @@ struct B_TimesD_SequenceD_bytearray {
     struct B_TimesD_SequenceD_bytearrayG_class *$class;
     B_Sequence W_Sequence;
 };
+extern GC_word B_TimesD_SequenceD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_SequenceD_bytearray)];
 struct B_ContainerD_bytearrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_ContainerD_bytearray);
@@ -3382,8 +3658,10 @@ struct B_ContainerD_bytearray {
     struct B_ContainerD_bytearrayG_class *$class;
     B_Eq W_EqD_AD_Container;
 };
+extern GC_word B_ContainerD_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_bytearray)];
 struct B_OrdD_bytesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_OrdD_bytes);
@@ -3402,8 +3680,10 @@ struct B_OrdD_bytesG_class {
 struct B_OrdD_bytes {
     struct B_OrdD_bytesG_class *$class;
 };
+extern GC_word B_OrdD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_OrdD_bytes)];
 struct B_SliceableD_bytesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_SliceableD_bytes);
@@ -3423,8 +3703,10 @@ struct B_SliceableD_bytes {
     struct B_SliceableD_bytesG_class *$class;
     B_Eq W_EqD_AD_Indexed;
 };
+extern GC_word B_SliceableD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_bytes)];
 struct B_ContainerD_bytesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_ContainerD_bytes);
@@ -3443,8 +3725,10 @@ struct B_ContainerD_bytes {
     struct B_ContainerD_bytesG_class *$class;
     B_Eq W_EqD_AD_Container;
 };
+extern GC_word B_ContainerD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_ContainerD_bytes)];
 struct B_TimesD_bytesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_TimesD_bytes);
@@ -3461,8 +3745,10 @@ struct B_TimesD_bytesG_class {
 struct B_TimesD_bytes {
     struct B_TimesD_bytesG_class *$class;
 };
+extern GC_word B_TimesD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_TimesD_bytes)];
 struct B_HashableD_bytesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_HashableD_bytes);
@@ -3478,6 +3764,7 @@ struct B_HashableD_bytesG_class {
 struct B_HashableD_bytes {
     struct B_HashableD_bytesG_class *$class;
 };
+extern GC_word B_HashableD_bytesD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_bytes)];
 extern struct B_valueG_class B_valueG_methods;
 B_value B_valueG_new();
 extern struct B_objectG_class B_objectG_methods;
@@ -3795,7 +4082,8 @@ typedef struct B_L_6proc *B_L_6proc;
 typedef struct B_WorldAuth *B_WorldAuth;
 typedef struct B_Env *B_Env;
 struct B_L_1procG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_L_1proc, B_Env, B_str);
@@ -3812,8 +4100,10 @@ struct B_L_1proc {
     B_Env self;
     B_str s;
 };
+extern GC_word B_L_1procD_gcbm[GC_BITMAP_SIZE(struct B_L_1proc)];
 struct B_L_2procG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_L_2proc, B_Env, $action);
@@ -3830,8 +4120,10 @@ struct B_L_2proc {
     B_Env self;
     $action cb;
 };
+extern GC_word B_L_2procD_gcbm[GC_BITMAP_SIZE(struct B_L_2proc)];
 struct B_L_3procG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_L_3proc, B_Env, B_int);
@@ -3848,9 +4140,11 @@ struct B_L_3proc {
     B_Env self;
     B_int n;
 };
+extern GC_word B_L_3procD_gcbm[GC_BITMAP_SIZE(struct B_L_3proc)];
 $R B_L_4C_1cont (B_Env, $Cont, B_NoneType);
 struct B_L_5ContG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_L_5Cont, B_Env, $Cont);
@@ -3866,8 +4160,10 @@ struct B_L_5Cont {
     B_Env G_act;
     $Cont C_cont;
 };
+extern GC_word B_L_5ContD_gcbm[GC_BITMAP_SIZE(struct B_L_5Cont)];
 struct B_L_6procG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_L_6proc, B_Env, B_WorldAuth, B_list);
@@ -3885,8 +4181,10 @@ struct B_L_6proc {
     B_WorldAuth token;
     B_list args;
 };
+extern GC_word B_L_6procD_gcbm[GC_BITMAP_SIZE(struct B_L_6proc)];
 struct B_WorldAuthG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_WorldAuth);
@@ -3899,8 +4197,10 @@ struct B_WorldAuthG_class {
 struct B_WorldAuth {
     struct B_WorldAuthG_class *$class;
 };
+extern GC_word B_WorldAuthD_gcbm[GC_BITMAP_SIZE(struct B_WorldAuth)];
 struct B_EnvG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     $R (*__init__) (B_Env, $Cont, B_WorldAuth, B_list);
@@ -3933,6 +4233,7 @@ struct B_Env {
     B_WorldAuth auth;
     B_list argv;
 };
+extern GC_word B_EnvD_gcbm[GC_BITMAP_SIZE(struct B_Env)];
 $R B_EnvG_newact ($Cont, B_WorldAuth, B_list);
 extern struct B_L_1procG_class B_L_1procG_methods;
 B_L_1proc B_L_1procG_new(B_Env, B_str);
diff --git a/builtin/atom.c b/builtin/atom.c
index 32e0cd8ab..9e53b4a81 100644
--- a/builtin/atom.c
+++ b/builtin/atom.c
@@ -13,6 +13,7 @@
  */
 
 struct B_atomG_class B_atomG_methods = {
+    0,
     "B_atom",
     UNASSIGNED,
     ($SuperG_class)&B_valueG_methods
diff --git a/builtin/bool.h b/builtin/bool.h
index a135ed82d..2d1577dd4 100644
--- a/builtin/bool.h
+++ b/builtin/bool.h
@@ -2,6 +2,7 @@ struct B_bool {
   struct B_boolG_class *$class;
   long val;
 };
+extern GC_word B_boolD_gcbm[GC_BITMAP_SIZE(struct B_bool)];
 
 B_bool toB_bool(long b);
 long fromB_bool(B_bool b);
diff --git a/builtin/builtin_functions.c b/builtin/builtin_functions.c
index 575e50cd5..4e1690512 100644
--- a/builtin/builtin_functions.c
+++ b/builtin/builtin_functions.c
@@ -91,8 +91,7 @@ B_IteratorD_enumerate B_IteratorD_enumerate$_deserialize(B_IteratorD_enumerate r
         return NULL;
 }
 
-struct B_IteratorD_enumerateG_class B_IteratorD_enumerateG_methods = {"B_IteratorD_enumerate",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_enumerate_init,
-                                                                B_IteratorD_enumerate_serialize, B_IteratorD_enumerate$_deserialize, 
+struct B_IteratorD_enumerateG_class B_IteratorD_enumerateG_methods = {0,"B_IteratorD_enumerate",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_enumerate_init,                                                                B_IteratorD_enumerate_serialize, B_IteratorD_enumerate$_deserialize, 
                                                                 B_IteratorD_enumerate_bool,B_IteratorD_enumerate_str,B_IteratorD_enumerate_str, B_IteratorD_enumerate_next};
 
 
@@ -143,8 +142,7 @@ B_IteratorD_filter B_IteratorD_filter$_deserialize(B_IteratorD_filter res, $Seri
     return w;
 }
 
-struct B_IteratorD_filterG_class B_IteratorD_filterG_methods = {"B_IteratorD_filter",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_filter_init,
-                                                          B_IteratorD_filter_serialize, B_IteratorD_filter$_deserialize, 
+struct B_IteratorD_filterG_class B_IteratorD_filterG_methods = {0,"B_IteratorD_filter",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_filter_init,                                                          B_IteratorD_filter_serialize, B_IteratorD_filter$_deserialize, 
                                                           B_IteratorD_filter_bool,B_IteratorD_filter_str,B_IteratorD_filter_str, B_IteratorD_filter_next};
 
 B_IteratorD_filter B_IteratorD_filterG_new(B_Iterator it, $pure f) {
@@ -192,8 +190,7 @@ B_IteratorD_map B_IteratorD_map$_deserialize(B_IteratorD_map res, $Serial$state
         return NULL;
 }
 
-struct B_IteratorD_mapG_class B_IteratorD_mapG_methods = {"B_IteratorD_map",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_map_init,
-                                                    B_IteratorD_map_serialize, B_IteratorD_map$_deserialize,  
+struct B_IteratorD_mapG_class B_IteratorD_mapG_methods = {0,"B_IteratorD_map",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_map_init,                                                    B_IteratorD_map_serialize, B_IteratorD_map$_deserialize,  
                                                     B_IteratorD_map_bool,B_IteratorD_map_str,B_IteratorD_map_str, B_IteratorD_map_next};
 
 B_IteratorD_map B_IteratorD_mapG_new(B_Iterator it, $pure f) {
@@ -293,8 +290,7 @@ B_IteratorD_zip B_IteratorD_zip$_deserialize(B_IteratorD_zip res, $Serial$state
         return NULL;
 }
 
-struct B_IteratorD_zipG_class B_IteratorD_zipG_methods = {" B_IteratorD_zip",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_zip_init,
-                                                    B_IteratorD_zip_serialize, B_IteratorD_zip$_deserialize, 
+struct B_IteratorD_zipG_class B_IteratorD_zipG_methods = {0," B_IteratorD_zip",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_zip_init,                                                    B_IteratorD_zip_serialize, B_IteratorD_zip$_deserialize, 
                                                     B_IteratorD_zip_bool,B_IteratorD_zip_str,B_IteratorD_zip_str, B_IteratorD_zip_next};
 
 B_IteratorD_zip B_IteratorD_zipG_new(B_Iterator iter1, B_Iterator iter2) {
@@ -325,8 +321,7 @@ B_bool B_EqOptD___ne__(B_EqOpt wit, $WORD a, $WORD b) {
     return (!a && !b) ? B_False : B_True;
 }
 
-struct B_EqOptG_class B_EqOptG_methods = {"B_EqOpt", UNASSIGNED, NULL, B_EqOptD___init__, B_EqOptD___eq__, B_EqOptD___ne__};
-
+struct B_EqOptG_class B_EqOptG_methods = {0,"B_EqOpt", UNASSIGNED, NULL, B_EqOptD___init__, B_EqOptD___eq__, B_EqOptD___ne__};
 
 B_EqOpt B_EqOptG_new(B_Eq W_Eq$A) {
     return $NEW(B_EqOpt, W_Eq$A);
diff --git a/builtin/builtin_functions.h b/builtin/builtin_functions.h
index c9637682b..3ca5237d7 100644
--- a/builtin/builtin_functions.h
+++ b/builtin/builtin_functions.h
@@ -8,7 +8,8 @@ struct B_IteratorD_enumerate;
 typedef struct B_IteratorD_enumerate *B_IteratorD_enumerate;
 
 struct B_IteratorD_enumerateG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   void (*__init__)(B_IteratorD_enumerate, B_Iterator,B_int);
@@ -25,6 +26,7 @@ struct B_IteratorD_enumerate {
   B_Iterator it;
   int nxt;
 };
+extern GC_word B_IteratorD_enumerateD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_enumerate)];
 
 extern struct B_IteratorD_enumerateG_class B_IteratorD_enumerateG_methods;
 B_IteratorD_enumerate B_IteratorD_enumerateG_new(B_Iterator,B_int);
@@ -38,7 +40,8 @@ struct B_IteratorD_filter;
 typedef struct B_IteratorD_filter *B_IteratorD_filter;
 
 struct B_IteratorD_filterG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   void (*__init__)(B_IteratorD_filter, B_Iterator, $pure);
@@ -55,6 +58,7 @@ struct B_IteratorD_filter {
   B_Iterator it;
   $pure f;
 };
+extern GC_word B_IteratorD_filterD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_filter)];
 
 extern struct B_IteratorD_filterG_class B_IteratorD_filterG_methods;
 B_IteratorD_filter B_IteratorD_filterG_new(B_Iterator, $pure);
@@ -67,7 +71,8 @@ struct B_IteratorD_map;
 typedef struct B_IteratorD_map *B_IteratorD_map;
 
 struct B_IteratorD_mapG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   void (*__init__)(B_IteratorD_map, B_Iterator, $pure);
@@ -84,6 +89,7 @@ struct B_IteratorD_map {
   B_Iterator it;
   $pure f;
 };
+extern GC_word B_IteratorD_mapD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_map)];
 
 extern struct B_IteratorD_mapG_class B_IteratorD_mapG_methods;
 B_IteratorD_map B_IteratorD_mapG_new(B_Iterator, $pure);
@@ -94,7 +100,8 @@ struct B_IteratorD_zip;
 typedef struct B_IteratorD_zip *B_IteratorD_zip;
 
 struct B_IteratorD_zipG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   void (*__init__)(B_IteratorD_zip, B_Iterator, B_Iterator);
@@ -111,6 +118,7 @@ struct B_IteratorD_zip {
   B_Iterator it1;
   B_Iterator it2;
 };
+extern GC_word B_IteratorD_zipD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_zip)];
 
 extern struct B_IteratorD_zipG_class B_IteratorD_zipG_methods;
 B_IteratorD_zip B_IteratorD_zipG_new(B_Iterator, B_Iterator);
@@ -124,7 +132,8 @@ struct B_EqOpt;
 typedef struct B_EqOpt *B_EqOpt;
 
 struct B_EqOptG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(B_EqOpt, B_Eq);
@@ -136,6 +145,7 @@ struct B_EqOpt {
     struct B_EqOptG_class *$class;
     B_Eq W_Eq$A;
 };
+extern GC_word B_EqOptD_gcbm[GC_BITMAP_SIZE(struct B_EqOpt)];
 
 B_EqOpt B_EqOptG_new(B_Eq);
 
diff --git a/builtin/class_hierarchy.c b/builtin/class_hierarchy.c
index 526a0c456..0118faaec 100644
--- a/builtin/class_hierarchy.c
+++ b/builtin/class_hierarchy.c
@@ -38,13 +38,13 @@ B_NoneType B_objectD___init__ (B_object self) {
 */
 B_str B_valueD___str__(B_value self) {
     char *s;
-    asprintf(&s,"<%s object at %p>",self->$class->$GCINFO,self);
+    asprintf(&s,"<%s object at %p>",self->$class->$name,self);
     return to$str(s);
 }
 
 B_str B_objectD___str__(B_object self) {
     char *s;
-    asprintf(&s,"<%s object at %p>",self->$class->$GCINFO,self);
+    asprintf(&s,"<%s object at %p>",self->$class->$name,self);
     return to$str(s);
 }
 
@@ -55,8 +55,7 @@ B_bool B_objectD___bool__(B_object self) {
     return B_True;
 }
 
-struct $SerializableG_class $SerializableG_methods = {"$Serializable",UNASSIGNED,NULL, $SerializableD___init__,NULL,NULL};
-
+struct $SerializableG_class $SerializableG_methods = {0,"$Serializable",UNASSIGNED,NULL, $SerializableD___init__,NULL,NULL};
 //struct B_valueG_class B_valueG_methods = {"B_value",UNASSIGNED,($SuperG_class)&$SerializableG_methods,B_valueD___init__,NULL,NULL, B_valueD___bool__,B_valueD___str__,B_valueD___str__};
 
 //struct B_objectG_class B_objectG_methods = {"B_object",UNASSIGNED,($SuperG_class)&B_valueG_methods,B_objectD___init__,NULL,NULL,B_objectD___bool__,B_objectD___str__,B_objectD___str__};
diff --git a/builtin/class_hierarchy.h b/builtin/class_hierarchy.h
index 086807897..3eb1883a7 100644
--- a/builtin/class_hierarchy.h
+++ b/builtin/class_hierarchy.h
@@ -4,7 +4,8 @@
 
 
 struct $SuperG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
 };
@@ -12,6 +13,7 @@ struct $SuperG_class {
 struct $Super {
     $SuperG_class $class;
 };
+extern GC_word $SuperD_gcbm[GC_BITMAP_SIZE(struct $Super)];
 
 /*
 typedef struct $InitializableG_class *$InitializableG_class;
@@ -19,7 +21,8 @@ typedef struct $InitializableG_class *$InitializableG_class;
 typedef struct $Initializable  *$Initializable;
 
 struct $InitializableG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;                   // = NULL
     B_NoneType (*__init__)($Initializable);
@@ -28,6 +31,7 @@ struct $InitializableG_class {
 struct $Initializable {
     struct $InitializableG_class *$class;
 };
+extern GC_word $InitializableD_gcbm[GC_BITMAP_SIZE(struct $Initializable)];
 
 extern struct $InitializableG_class $InitializableG_methods;
 $Initializable $InitializableG_new();
@@ -36,7 +40,8 @@ extern struct $InitializableG_class $InitializableG_methods;
 // Serializable //////////////////////////////////////////////////////
 
 struct $SerializableG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;                   // = InitializableG_methods
     B_NoneType (*__init__)($Serializable);
@@ -47,6 +52,7 @@ struct $SerializableG_class {
 struct $Serializable {
     struct $SerializableG_class *$class;
 };
+extern GC_word $SerializableD_gcbm[GC_BITMAP_SIZE(struct $Serializable)];
 
 extern struct $SerializableG_class $SerializableG_methods;
 $Serializable $SerializableG_new();
diff --git a/builtin/complex.c b/builtin/complex.c
index dce5ca084..95315da73 100644
--- a/builtin/complex.c
+++ b/builtin/complex.c
@@ -185,6 +185,7 @@ struct B_EqD_complex B_EqD_complex_instance;
 struct B_HashableD_complex B_HashableD_complex_instance;
 
 struct B_NumberD_complexG_class B_NumberD_complexG_methods = {
+    0,
     "B_NumberD_complex",
     UNASSIGNED,
     ($SuperG_class)&B_NumberG_methods,
@@ -213,6 +214,7 @@ struct B_NumberD_complex B_NumberD_complex_instance = {&B_NumberD_complexG_metho
 B_NumberD_complex B_NumberD_complexG_witness = &B_NumberD_complex_instance;
 
 struct B_DivD_complexG_class B_DivD_complexG_methods = {
+    0,
     "B_DivD_complex",
     UNASSIGNED,
     ($SuperG_class)&B_DivG_methods,
@@ -230,6 +232,7 @@ struct B_DivD_complex B_DivD_complex_instance = {&B_DivD_complexG_methods};
 B_DivD_complex B_DivD_complexG_witness = &B_DivD_complex_instance;
 
 struct B_MinusD_NumberD_complexG_class B_MinusD_NumberD_complexG_methods = {
+    0,
     "B_MinusD_NumberD_complex",
     UNASSIGNED,
     ($SuperG_class)&B_MinusG_methods,
@@ -246,6 +249,7 @@ struct B_MinusD_NumberD_complex B_MinusD_NumberD_complex_instance = {&B_MinusD_N
 B_MinusD_NumberD_complex B_MinusD_NumberD_complexG_witness = &B_MinusD_NumberD_complex_instance;
 
 struct B_EqD_complexG_class B_EqD_complexG_methods = {
+    0,
     "B_EqD_complex",
     UNASSIGNED,
     ($SuperG_class)&B_EqG_methods,
@@ -262,6 +266,7 @@ struct B_EqD_complex B_EqD_complex_instance = {&B_EqD_complexG_methods};
 B_EqD_complex B_EqD_complexG_witness = &B_EqD_complex_instance;
 
 struct B_HashableD_complexG_class B_HashableD_complexG_methods = {
+    0,
     "B_HashableD_complex",
     UNASSIGNED,
     ($SuperG_class)&B_HashableG_methods,
diff --git a/builtin/complx.h b/builtin/complx.h
index 6c7f56738..7dc965436 100644
--- a/builtin/complx.h
+++ b/builtin/complx.h
@@ -9,6 +9,7 @@ struct B_complex {
     struct B_complexG_class *$class;
     complex double val;
 };
+extern GC_word B_complexD_gcbm[GC_BITMAP_SIZE(struct B_complex)];
 
 B_complex toB_complex(complex double c);
 
diff --git a/builtin/dict.c b/builtin/dict.c
index 6722eb5e2..07519ecb0 100644
--- a/builtin/dict.c
+++ b/builtin/dict.c
@@ -394,8 +394,7 @@ B_IteratorD_dict B_IteratorD_dict__deserialize(B_IteratorD_dict res, $Serial$sta
 }
 
 
-struct B_IteratorD_dictG_class B_IteratorD_dictG_methods = {"B_IteratorD_dict",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dictD_init,
-                                                      B_IteratorD_dictD_serialize, B_IteratorD_dict__deserialize, B_IteratorD_dictD_bool,B_IteratorD_dictD_str,B_IteratorD_dictD_str, B_IteratorD_dictD_next};
+struct B_IteratorD_dictG_class B_IteratorD_dictG_methods = {0,"B_IteratorD_dict",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dictD_init,                                                      B_IteratorD_dictD_serialize, B_IteratorD_dict__deserialize, B_IteratorD_dictD_bool,B_IteratorD_dictD_str,B_IteratorD_dictD_str, B_IteratorD_dictD_next};
 
 
 B_Iterator B_MappingD_dictD___iter__ (B_MappingD_dict wit, B_dict dict) {
@@ -500,8 +499,7 @@ B_IteratorD_dict_values B_IteratorD_dict_values_deserialize(B_IteratorD_dict_val
     return res;
 }
 
-struct B_IteratorD_dict_valuesG_class B_IteratorD_dict_valuesG_methods = {"B_IteratorD_dict_values",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dict_values_init,
-                                                                    B_IteratorD_dict_values_serialize, B_IteratorD_dict_values_deserialize, B_IteratorD_dict_values_bool, B_IteratorD_dict_values_str,B_IteratorD_dict_values_str,
+struct B_IteratorD_dict_valuesG_class B_IteratorD_dict_valuesG_methods = {0,"B_IteratorD_dict_values",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dict_values_init,                                                                    B_IteratorD_dict_values_serialize, B_IteratorD_dict_values_deserialize, B_IteratorD_dict_values_bool, B_IteratorD_dict_values_str,B_IteratorD_dict_values_str,
                                                                     B_IteratorD_dict_values_next};
 
 // items iterator
@@ -556,8 +554,7 @@ B_IteratorD_dict_items B_IteratorD_dict_items_deserialize(B_IteratorD_dict_items
 
 
 
-struct B_IteratorD_dict_itemsG_class B_IteratorD_dict_itemsG_methods = {"B_IteratorD_dict_items",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dict_items_init,
-                                                                  B_IteratorD_dict_items_serialize, B_IteratorD_dict_items_deserialize,B_IteratorD_dict_items_bool, B_IteratorD_dict_items_str, B_IteratorD_dict_items_str, B_IteratorD_dict_items_next};
+struct B_IteratorD_dict_itemsG_class B_IteratorD_dict_itemsG_methods = {0,"B_IteratorD_dict_items",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_dict_items_init,                                                                  B_IteratorD_dict_items_serialize, B_IteratorD_dict_items_deserialize,B_IteratorD_dict_items_bool, B_IteratorD_dict_items_str, B_IteratorD_dict_items_str, B_IteratorD_dict_items_next};
 
 
 B_Iterator B_MappingD_dictD_values (B_MappingD_dict wit, B_dict dict) {
@@ -704,6 +701,7 @@ struct  B_MappingD_dictG_class B_MappingD_dictG_methods = {
 };
 
 struct B_IndexedD_MappingD_dictG_class B_IndexedD_MappingD_dictG_methods = {
+    0,
     "B_IndexedD_MappingD_dict",
     UNASSIGNED,
     ($SuperG_class)&B_IndexedG_methods,
@@ -720,6 +718,7 @@ struct B_IndexedD_MappingD_dictG_class B_IndexedD_MappingD_dictG_methods = {
 
 
 struct B_OrdD_dictG_class B_OrdD_dictG_methods = {
+    0,
     "B_OrdD_dict",
     UNASSIGNED,
     ($SuperG_class)&B_OrdG_methods,
diff --git a/builtin/dict.h b/builtin/dict.h
index 1dae6acdc..513c016f9 100644
--- a/builtin/dict.h
+++ b/builtin/dict.h
@@ -5,6 +5,7 @@ struct B_dict {
     long numelements;               // nr of elements in dictionary
     $table table;                   // the hashtable
 };
+extern GC_word B_dictD_gcbm[GC_BITMAP_SIZE(struct B_dict)];
 
 // Iterators over dicts ///////////////////////////////////////////////////////
 
@@ -13,7 +14,8 @@ struct B_dict {
 typedef struct B_IteratorD_dict *B_IteratorD_dict;
 
 struct B_IteratorD_dictG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(B_IteratorD_dict, B_dict);
@@ -30,6 +32,7 @@ struct B_IteratorD_dict {
     B_dict src;
     int nxt;
 };
+extern GC_word B_IteratorD_dictD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_dict)];
 
 extern struct B_IteratorD_dictG_class  B_IteratorD_dictG_methods;
 B_IteratorD_dict B_IteratorD_dictG_new(B_dict);
@@ -39,7 +42,8 @@ B_IteratorD_dict B_IteratorD_dictG_new(B_dict);
 typedef struct B_IteratorD_dict_values *B_IteratorD_dict_values;
 
 struct B_IteratorD_dict_valuesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(B_IteratorD_dict_values, B_dict);
@@ -56,6 +60,7 @@ struct B_IteratorD_dict_values {
     B_dict src;
     int nxt;
 };
+extern GC_word B_IteratorD_dict_valuesD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_dict_values)];
 
 extern struct B_IteratorD_dict_valuesG_class  B_IteratorD_dict_valuesG_methods;
 B_IteratorD_dict_values B_IteratorD_dict_valuesG_new(B_dict);
@@ -65,7 +70,8 @@ B_IteratorD_dict_values B_IteratorD_dict_valuesG_new(B_dict);
 typedef struct B_IteratorD_dict_items *B_IteratorD_dict_items;
 
 struct B_IteratorD_dict_itemsG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(B_IteratorD_dict_items, B_dict);
@@ -82,6 +88,7 @@ struct B_IteratorD_dict_items {
     B_dict src;
     int nxt;
 };
+extern GC_word B_IteratorD_dict_itemsD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_dict_items)];
 
 extern struct B_IteratorD_dict_itemsG_class  B_IteratorD_dict_itemsG_methods;
 B_IteratorD_dict_items B_IteratorD_dict_itemsG_new(B_dict);
diff --git a/builtin/env.c b/builtin/env.c
index 9ae71a88f..a6bb2525a 100644
--- a/builtin/env.c
+++ b/builtin/env.c
@@ -46,7 +46,7 @@ void $l$1contD___serialize__ ($l$1cont self, $Serial$state state) {
 $l$1cont $l$1contD___deserialize__ ($l$1cont self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct $l$1cont));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$1cont), $l$1contG_methods.$GCdescr);
             self->$class = &$l$1contG_methods;
             return self;
         }
@@ -57,12 +57,13 @@ void $l$1contD___serialize__ ($l$1cont self, $Serial$state state) {
     return self;
 }
 $l$1cont $l$1contG_new(B_Env p$1, B_str p$2) {
-    $l$1cont $tmp = malloc(sizeof(struct $l$1cont));
+    $l$1cont $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$1cont), $l$1contG_methods.$GCdescr);
     $tmp->$class = &$l$1contG_methods;
     $l$1contG_methods.__init__($tmp, p$1, p$2);
     return $tmp;
 }
 struct $l$1contG_class $l$1contG_methods;
+GC_word $l$1contD_gcbm[GC_BITMAP_SIZE(struct $l$1cont)];
 
 B_NoneType $l$2contD___init__ ($l$2cont p$self, B_Env self, $action cb) {
     p$self->self = self;
@@ -81,7 +82,7 @@ void $l$2contD___serialize__ ($l$2cont self, $Serial$state state) {
 $l$2cont $l$2contD___deserialize__ ($l$2cont self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct $l$2cont));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$2cont), $l$2contG_methods.$GCdescr);
             self->$class = &$l$2contG_methods;
             return self;
         }
@@ -92,12 +93,13 @@ void $l$2contD___serialize__ ($l$2cont self, $Serial$state state) {
     return self;
 }
 $l$2cont $l$2contG_new(B_Env p$1, $action p$2) {
-    $l$2cont $tmp = malloc(sizeof(struct $l$2cont));
+    $l$2cont $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$2cont), $l$2contG_methods.$GCdescr);
     $tmp->$class = &$l$2contG_methods;
     $l$2contG_methods.__init__($tmp, p$1, p$2);
     return $tmp;
 }
 struct $l$2contG_class $l$2contG_methods;
+GC_word $l$2contD_gcbm[GC_BITMAP_SIZE(struct $l$2cont)];
 
 B_NoneType $l$3contD___init__ ($l$3cont p$self, B_Env self, B_int n) {
     p$self->self = self;
@@ -116,7 +118,7 @@ void $l$3contD___serialize__ ($l$3cont self, $Serial$state state) {
 $l$3cont $l$3contD___deserialize__ ($l$3cont self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct $l$3cont));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$3cont), $l$3contG_methods.$GCdescr);
             self->$class = &$l$3contG_methods;
             return self;
         }
@@ -127,12 +129,13 @@ void $l$3contD___serialize__ ($l$3cont self, $Serial$state state) {
     return self;
 }
 $l$3cont $l$3contG_new(B_Env p$1, B_int p$2) {
-    $l$3cont $tmp = malloc(sizeof(struct $l$3cont));
+    $l$3cont $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct $l$3cont), $l$3contG_methods.$GCdescr);
     $tmp->$class = &$l$3contG_methods;
     $l$3contG_methods.__init__($tmp, p$1, p$2);
     return $tmp;
 }
 struct $l$3contG_class $l$3contG_methods;
+GC_word $l$3contD_gcbm[GC_BITMAP_SIZE(struct $l$3cont)];
 B_NoneType B_WorldAuthD___init__ (B_WorldAuth self) {
     return B_None;
 }
@@ -141,7 +144,7 @@ void B_WorldAuthD___serialize__ (B_WorldAuth self, $Serial$state state) {
 B_WorldAuth B_WorldAuthD___deserialize__ (B_WorldAuth self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_WorldAuth));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_WorldAuth), B_WorldAuthG_methods.$GCdescr);
             self->$class = &B_WorldAuthG_methods;
             return self;
         }
@@ -150,6 +153,7 @@ B_WorldAuth B_WorldAuthD___deserialize__ (B_WorldAuth self, $Serial$state state)
     return self;
 }
 struct B_WorldAuthG_class B_WorldAuthG_methods;
+GC_word B_WorldAuthD_gcbm[GC_BITMAP_SIZE(struct B_WorldAuth)];
 B_Msg B_Env$stdout_write (B_Env self, B_str s) {
     return $ASYNC((($Actor)self), (($Cont)$l$1contG_new(((B_Env)self), s)));
 }
@@ -164,7 +168,7 @@ B_Msg B_Env$exit (B_Env self, B_int n) {
 
 
 B_WorldAuth B_WorldAuthG_new() {
-    B_WorldAuth $tmp = malloc(sizeof(struct B_WorldAuth));
+    B_WorldAuth $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_WorldAuth), B_WorldAuthG_methods.$GCdescr);
     $tmp->$class = &B_WorldAuthG_methods;
     B_WorldAuthG_methods.__init__($tmp);
     return $tmp;
@@ -221,7 +225,7 @@ void B_EnvD___serialize__ (B_Env self, $Serial$state state) {
 B_Env B_EnvD___deserialize__ (B_Env self, $Serial$state state) {
     if (!self) {
         if (!state) {
-            self = malloc(sizeof(struct B_Env));
+            self = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct B_Env), B_EnvG_methods.$GCdescr);
             self->$class = &B_EnvG_methods;
             return self;
         }
@@ -238,6 +242,7 @@ B_Env B_EnvG_newact(B_WorldAuth token, B_list p$1) {
     return $tmp;
 }
 struct B_EnvG_class B_EnvG_methods;
+GC_word B_EnvD_gcbm[GC_BITMAP_SIZE(struct B_Env)];
 
 
 int $done$ = 0;
@@ -247,7 +252,9 @@ void D___init__ () {
     ///////////////////////////////////////////////////////////////////////////////////////
     // START GENERATED __builtin__.act D___init__
     {
-        $l$1contG_methods.$GCINFO = "$l$1cont";
+        memset($l$1contD_gcbm, 0xFF, sizeof($l$1contD_gcbm));
+        $l$1contG_methods.$GCdescr = GC_make_descriptor($l$1contD_gcbm, GC_WORD_LEN(struct $l$1cont));
+        $l$1contG_methods.$name = "$l$1cont";
         $l$1contG_methods.$superclass = ($SuperG_class)&$ContG_methods;
         $l$1contG_methods.__init__ = $l$1contD___init__;
         $l$1contG_methods.__call__ = $l$1contD___call__;
@@ -256,7 +263,9 @@ void D___init__ () {
         $register(&$l$1contG_methods);
     }
     {
-        $l$2contG_methods.$GCINFO = "$l$2cont";
+        memset($l$2contD_gcbm, 0xFF, sizeof($l$2contD_gcbm));
+        $l$2contG_methods.$GCdescr = GC_make_descriptor($l$2contD_gcbm, GC_WORD_LEN(struct $l$2cont));
+        $l$2contG_methods.$name = "$l$2cont";
         $l$2contG_methods.$superclass = ($SuperG_class)&$ContG_methods;
         $l$2contG_methods.__init__ = $l$2contD___init__;
         $l$2contG_methods.__call__ = $l$2contD___call__;
@@ -265,7 +274,9 @@ void D___init__ () {
         $register(&$l$2contG_methods);
     }
     {
-        $l$3contG_methods.$GCINFO = "$l$3cont";
+        memset($l$3contD_gcbm, 0xFF, sizeof($l$3contD_gcbm));
+        $l$3contG_methods.$GCdescr = GC_make_descriptor($l$3contD_gcbm, GC_WORD_LEN(struct $l$3cont));
+        $l$3contG_methods.$name = "$l$3cont";
         $l$3contG_methods.$superclass = ($SuperG_class)&$ContG_methods;
         $l$3contG_methods.__init__ = $l$3contD___init__;
         $l$3contG_methods.__call__ = $l$3contD___call__;
@@ -274,7 +285,9 @@ void D___init__ () {
         $register(&$l$3contG_methods);
     }
     {
-        B_WorldAuthG_methods.$GCINFO = "B_WorldAuth";
+        memset(B_WorldAuthD_gcbm, 0xFF, sizeof(B_WorldAuthD_gcbm));
+        B_WorldAuthG_methods.$GCdescr = GC_make_descriptor(B_WorldAuthD_gcbm, GC_WORD_LEN(struct B_WorldAuth));
+        B_WorldAuthG_methods.$name = "B_WorldAuth";
         B_WorldAuthG_methods.$superclass = ($SuperG_class)&B_valueG_methods;
         ;
         B_WorldAuthG_methods.__init__ = B_WorldAuthD___init__;
@@ -283,7 +296,9 @@ void D___init__ () {
         $register(&B_WorldAuthG_methods);
     }
     {
-        B_EnvG_methods.$GCINFO = "B_Env";
+        memset(B_EnvD_gcbm, 0xFF, sizeof(B_EnvD_gcbm));
+        B_EnvG_methods.$GCdescr = GC_make_descriptor(B_EnvD_gcbm, GC_WORD_LEN(struct B_Env));
+        B_EnvG_methods.$name = "B_Env";
         B_EnvG_methods.$superclass = ($SuperG_class)&$ActorG_methods;
         B_EnvG_methods.__bool__ = (B_bool (*) (B_Env))$ActorG_methods.__bool__;
         B_EnvG_methods.__str__ = (B_str (*) (B_Env))$ActorG_methods.__str__;
diff --git a/builtin/env.h b/builtin/env.h
index c8dc298e7..77c921ac9 100644
--- a/builtin/env.h
+++ b/builtin/env.h
@@ -44,7 +44,8 @@ typedef struct $l$3cont *$l$3cont;
 typedef struct B_WorldAuth *B_WorldAuth;
 typedef struct B_Env *B_Env;
 struct $l$1contG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) ($l$1cont, B_Env, B_str);
@@ -60,8 +61,10 @@ struct $l$1cont {
     B_Env self;
     B_str s;
 };
+extern GC_word $l$1contD_gcbm[GC_BITMAP_SIZE(struct $l$1cont)];
 struct $l$2contG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) ($l$2cont, B_Env, $action);
@@ -77,8 +80,10 @@ struct $l$2cont {
     B_Env self;
     $action cb;
 };
+extern GC_word $l$2contD_gcbm[GC_BITMAP_SIZE(struct $l$2cont)];
 struct $l$3contG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) ($l$3cont, B_Env, B_int);
@@ -94,8 +99,10 @@ struct $l$3cont {
     B_Env self;
     B_int n;
 };
+extern GC_word $l$3contD_gcbm[GC_BITMAP_SIZE(struct $l$3cont)];
 struct B_WorldAuthG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_WorldAuth);
@@ -108,6 +115,7 @@ struct B_WorldAuthG_class {
 struct B_WorldAuth {
     struct B_WorldAuthG_class *$class;
 };
+extern GC_word B_WorldAuthD_gcbm[GC_BITMAP_SIZE(struct B_WorldAuth)];
 B_WorldAuth B_WorldAuthG_new();
 extern struct $l$1contG_class $l$1contG_methods;
 $l$1cont $l$1contG_new(B_Env, B_str);
@@ -120,7 +128,8 @@ extern struct B_WorldAuthG_class B_WorldAuthG_methods;
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 struct B_EnvG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (B_Env, B_WorldAuth, B_list);
@@ -151,6 +160,7 @@ struct B_Env {
     B_WorldAuth auth;
     B_list argv;
 };
+extern GC_word B_EnvD_gcbm[GC_BITMAP_SIZE(struct B_Env)];
 
 extern struct B_EnvG_class B_EnvG_methods;
 B_Env B_EnvG_newact(B_WorldAuth, B_list);
diff --git a/builtin/float.c b/builtin/float.c
index f37e7991a..63b50371a 100644
--- a/builtin/float.c
+++ b/builtin/float.c
@@ -262,6 +262,7 @@ struct B_OrdD_float B_OrdD_float_instance;
 struct B_HashableD_float B_HashableD_float_instance;
 
 struct B_RealFloatD_floatG_class B_RealFloatD_floatG_methods = {
+    0,
     "B_RealFloatD_float",
     UNASSIGNED,
     ($SuperG_class)&B_RealG_methods,
@@ -295,6 +296,7 @@ struct B_RealFloatD_float B_RealFloatD_float_instance = {&B_RealFloatD_floatG_me
 B_RealFloatD_float B_RealFloatD_floatG_witness = &B_RealFloatD_float_instance;
 
 struct B_MinusD_RealFloatD_floatG_class B_MinusD_RealFloatD_floatG_methods = {
+    0,
     "B_MinusD_RealFloatD_float",
     UNASSIGNED,
     ($SuperG_class)&B_MinusG_methods,
@@ -312,6 +314,7 @@ struct B_MinusD_RealFloatD_float B_MinusD_RealFloatD_float_instance = {&B_MinusD
 B_MinusD_RealFloatD_float B_MinusD_RealFloatD_floatG_witness = &B_MinusD_RealFloatD_float_instance;
 
 struct B_DivD_floatG_class B_DivD_floatG_methods = {
+    0,
     "B_DivD_float",
     UNASSIGNED,
     ($SuperG_class)&B_DivG_methods,
@@ -330,6 +333,7 @@ B_DivD_float B_DivD_floatG_witness = &B_DivD_float_instance;
 
 
 struct B_OrdD_floatG_class B_OrdD_floatG_methods = {
+    0,
     "B_OrdD_float",
     UNASSIGNED,
     ($SuperG_class)&B_OrdG_methods,
@@ -350,6 +354,7 @@ struct B_OrdD_float B_OrdD_float_instance = {&B_OrdD_floatG_methods};
 B_OrdD_float B_OrdD_floatG_witness = &B_OrdD_float_instance;
 
 struct B_HashableD_floatG_class B_HashableD_floatG_methods = {
+    0,
     "B_HashableD_float",
     UNASSIGNED,
     ($SuperG_class)&B_HashableG_methods,
diff --git a/builtin/float.h b/builtin/float.h
index 8ea58722c..9b04d9a37 100644
--- a/builtin/float.h
+++ b/builtin/float.h
@@ -3,6 +3,7 @@ struct B_float {
     struct B_floatG_class *$class;
     double val;
 };
+extern GC_word B_floatD_gcbm[GC_BITMAP_SIZE(struct B_float)];
 
 // #define B_RealD_floatG_new(...) B_RealFloatG_new(__VA_ARGS__)
 // #define B_RealD_float B_RealFloat
diff --git a/builtin/function.c b/builtin/function.c
index 9f5e7be57..c048c5241 100644
--- a/builtin/function.c
+++ b/builtin/function.c
@@ -69,6 +69,7 @@ void $ContD___serialize__($Cont self, $Serial$state state) {
 }
 
 struct $ContG_class $ContG_methods = {
+    0,
     "$Cont",
     UNASSIGNED,
     NULL,
@@ -81,6 +82,7 @@ struct $ContG_class $ContG_methods = {
     NULL                /* __call__ */
 };
 struct $procG_class $procG_methods = {
+    0,
     "$proc",
     UNASSIGNED,
     NULL,
@@ -94,6 +96,7 @@ struct $procG_class $procG_methods = {
     NULL                /* __exec__ */
 };
 struct $actionG_class $actionG_methods = {
+    0,
     "$action",
     UNASSIGNED,
     NULL,
@@ -108,6 +111,7 @@ struct $actionG_class $actionG_methods = {
     NULL                /* __asyn__ */
 };
 struct $mutG_class $mutG_methods = {
+    0,
     "$mut",
     UNASSIGNED,
     NULL,
@@ -122,6 +126,7 @@ struct $mutG_class $mutG_methods = {
     NULL                /* __eval__ */
 };
 struct $pureG_class $pureG_methods = {
+    0,
     "$pure",
     UNASSIGNED,
     NULL,
diff --git a/builtin/function.h b/builtin/function.h
index 489330eca..bf1cc0290 100644
--- a/builtin/function.h
+++ b/builtin/function.h
@@ -35,7 +35,8 @@ typedef struct $R $R;
 
 
 struct $ContG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($Cont);
@@ -49,6 +50,7 @@ struct $ContG_class {
 struct $Cont {
     struct $ContG_class *$class;
 };
+extern GC_word $ContD_gcbm[GC_BITMAP_SIZE(struct $Cont)];
 extern struct $ContG_class $ContG_methods;
 
 void $ContD___init__($Cont);
@@ -59,7 +61,8 @@ void $ContD___serialize__($Cont, $Serial$state);
 
 
 struct $procG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($proc);
@@ -74,11 +77,13 @@ struct $procG_class {
 struct $proc {
     struct $procG_class *$class;
 };
+extern GC_word $procD_gcbm[GC_BITMAP_SIZE(struct $proc)];
 extern struct $procG_class $procG_methods;
 
 
 struct $actionG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($action);
@@ -94,11 +99,13 @@ struct $actionG_class {
 struct $action {
     struct $actionG_class *$class;
 };
+extern GC_word $actionD_gcbm[GC_BITMAP_SIZE(struct $action)];
 extern struct $actionG_class $actionG_methods;
 
 
 struct $mutG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($mut);
@@ -114,11 +121,13 @@ struct $mutG_class {
 struct $mut {
     struct $mutG_class *$class;
 };
+extern GC_word $mutD_gcbm[GC_BITMAP_SIZE(struct $mut)];
 extern struct $mutG_class $mutG_methods;
 
 
 struct $pureG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($pure);
@@ -134,6 +143,7 @@ struct $pureG_class {
 struct $pure {
     struct $pureG_class *$class;
 };
+extern GC_word $pureD_gcbm[GC_BITMAP_SIZE(struct $pure)];
 extern struct $pureG_class $pureG_methods;
 
 
@@ -141,7 +151,8 @@ extern struct $pureG_class $pureG_methods;
 struct $action2;
 typedef struct $action2 *$action2;
 struct $action2G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($action2);
@@ -157,11 +168,13 @@ struct $action2G_class {
 struct $action2 {
     struct $action2G_class *$class;
 };
+extern GC_word $action2D_gcbm[GC_BITMAP_SIZE(struct $action2)];
 
 struct $action3;
 typedef struct $action3 *$action3;
 struct $action3G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($action3);
@@ -177,3 +190,4 @@ struct $action3G_class {
 struct $action3 {
     struct $action3G_class *$class;
 };
+extern GC_word $action3D_gcbm[GC_BITMAP_SIZE(struct $action3)];
diff --git a/builtin/i16.h b/builtin/i16.h
index e05ad66c3..8de22a4f9 100644
--- a/builtin/i16.h
+++ b/builtin/i16.h
@@ -2,6 +2,7 @@ struct B_i16 {
     struct B_i16G_class *$class;
     short val;
 };
+extern GC_word B_i16D_gcbm[GC_BITMAP_SIZE(struct B_i16)];
 
  
 B_i16 toB_i16(short n);
diff --git a/builtin/i32.h b/builtin/i32.h
index 37e4a10b2..81c37edad 100644
--- a/builtin/i32.h
+++ b/builtin/i32.h
@@ -2,6 +2,7 @@ struct B_i32 {
     struct B_i32G_class *$class;
     int val;
 };
+extern GC_word B_i32D_gcbm[GC_BITMAP_SIZE(struct B_i32)];
 
  
 B_i32 toB_i32(int n);
diff --git a/builtin/i64.h b/builtin/i64.h
index 47d31454a..c9aa56b2a 100644
--- a/builtin/i64.h
+++ b/builtin/i64.h
@@ -2,6 +2,7 @@ struct B_i64 {
     struct B_i64G_class *$class;
     long val;
 };
+extern GC_word B_i64D_gcbm[GC_BITMAP_SIZE(struct B_i64)];
 
  
 B_i64 toB_i64(long n);
diff --git a/builtin/int.c b/builtin/int.c
index b96eab018..04d8b118a 100644
--- a/builtin/int.c
+++ b/builtin/int.c
@@ -476,6 +476,7 @@ struct B_DivD_int B_DivD_int_instance;
 struct B_HashableD_int B_HashableD_int_instance;
 /*
 struct B_IntegralD_intG_class B_IntegralD_intG_methods = {
+    0,
     "B_IntegralD_int",
     UNASSIGNED,
     ($SuperG_class)&B_IntegralG_methods,
@@ -545,6 +546,7 @@ struct B_LogicalD_IntegralD_int B_LogicalD_IntegralD_int_instance = {&B_LogicalD
 B_LogicalD_IntegralD_int B_LogicalD_IntegralD_intG_witness = &B_LogicalD_IntegralD_int_instance;
 /*
 struct B_MinusD_IntegralD_intG_class B_MinusD_IntegralD_intG_methods = {
+    0,
     "B_MinusD_IntegralD_int",
     UNASSIGNED,
     ($SuperG_class)&B_MinusG_methods,
@@ -562,6 +564,7 @@ struct B_MinusD_IntegralD_int B_MinusD_IntegralD_int_instance = {&B_MinusD_Integ
 B_MinusD_IntegralD_int B_MinusD_IntegralD_intG_witness = &B_MinusD_IntegralD_int_instance;
 /*
 struct B_OrdD_intG_class B_OrdD_intG_methods = {
+    0,
     "B_OrdD_int",
     UNASSIGNED,
     ($SuperG_class)&B_OrdG_methods,
@@ -583,6 +586,7 @@ struct B_OrdD_int B_OrdD_int_instance = {&B_OrdD_intG_methods};
 B_OrdD_int B_OrdD_intG_witness = &B_OrdD_int_instance;
 /*
 struct B_DivD_intG_class B_DivD_intG_methods = {
+    0,
     "B_DivD_int",
     UNASSIGNED,
     ($SuperG_class)&B_DivG_methods,
@@ -600,6 +604,7 @@ struct B_DivD_int B_DivD_int_instance = {&B_DivD_intG_methods};
 B_DivD_int B_DivD_intG_witness = &B_DivD_int_instance;
 /*
 struct B_HashableD_intG_class B_HashableD_intG_methods = {
+    0,
     "B_HashableD_int",
     UNASSIGNED,
     ($SuperG_class)&B_HashableG_methods,
diff --git a/builtin/int.h b/builtin/int.h
index b0166671d..a23c56cc2 100644
--- a/builtin/int.h
+++ b/builtin/int.h
@@ -4,6 +4,7 @@ struct B_int {
     struct B_intG_class *$class;
     zz_struct val;
 };
+extern GC_word B_intD_gcbm[GC_BITMAP_SIZE(struct B_int)];
 
 extern struct B_IntegralD_int *B_IntegralD_intG_witness;
 extern struct B_HashableD_int *B_HashableD_intG_witness;
diff --git a/builtin/list.c b/builtin/list.c
index d6940becd..d16136395 100644
--- a/builtin/list.c
+++ b/builtin/list.c
@@ -291,8 +291,7 @@ B_IteratorD_list B_IteratorD_list$_deserialize(B_IteratorD_list res, $Serial$sta
     return res;
 }
 
-struct B_IteratorD_listG_class B_IteratorD_listG_methods = {"B_IteratorD_list",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_listD_init,
-                                                      B_IteratorD_listD_serialize, B_IteratorD_list$_deserialize,B_IteratorD_listD_bool,B_IteratorD_listD_str,B_IteratorD_listD_str,B_IteratorD_listD_next};
+struct B_IteratorD_listG_class B_IteratorD_listG_methods = {0,"B_IteratorD_list",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_listD_init,                                                      B_IteratorD_listD_serialize, B_IteratorD_list$_deserialize,B_IteratorD_listD_bool,B_IteratorD_listD_str,B_IteratorD_listD_str,B_IteratorD_listD_next};
 
 // Now, we can define the protocol methods
 
@@ -490,6 +489,7 @@ B_bool B_ContainerD_listD___containsnot__(B_ContainerD_list wit, B_list lst, $WO
 // so we need to initialize the below method table here, even if it is done in B___init__.
 
 struct B_SequenceD_listG_class B_SequenceD_listG_methods = {
+    0,
     "B_SequenceD_list", 
     UNASSIGNED,
     ($SuperG_class)&B_SequenceG_methods,
diff --git a/builtin/list.h b/builtin/list.h
index 546f020ee..9d76ab092 100644
--- a/builtin/list.h
+++ b/builtin/list.h
@@ -5,6 +5,7 @@ struct B_list {
   int length;
   int capacity;
 };
+extern GC_word B_listD_gcbm[GC_BITMAP_SIZE(struct B_list)];
 
 extern struct B_SequenceD_list *B_SequenceD_listG_witness;
 extern struct B_CollectionD_SequenceD_list *B_CollectionD_SequenceD_listG_witness;
@@ -17,7 +18,8 @@ extern struct B_CollectionD_SequenceD_list *B_CollectionD_SequenceD_listG_witnes
 typedef struct B_IteratorD_list *B_IteratorD_list; ;
 
 struct B_IteratorD_listG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   void (*__init__)(B_IteratorD_list, B_list);
@@ -34,6 +36,7 @@ struct B_IteratorD_list {
   B_list src;
   int nxt;
 };
+extern GC_word B_IteratorD_listD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_list)];
 
 extern struct  B_IteratorD_listG_class  B_IteratorD_listG_methods;
 B_IteratorD_list B_IteratorD_listG_new(B_list);
diff --git a/builtin/none.c b/builtin/none.c
index df80b8a8c..b0109c862 100644
--- a/builtin/none.c
+++ b/builtin/none.c
@@ -35,5 +35,4 @@ B_str B_NoneTypeD__str__(B_NoneType self) {
   return to$str("None");
 }
 
-struct B_NoneTypeG_class B_NoneTypeG_methods = {"B_NoneType",UNASSIGNED,($SuperG_class)&B_valueG_methods,(void (*)(B_NoneType))$default__init__,
-                                            B_NoneTypeD__serialize__,  B_NoneTypeD__deserialize__, B_NoneTypeD__bool__, B_NoneTypeD__str__, B_NoneTypeD__str__};
+struct B_NoneTypeG_class B_NoneTypeG_methods = {0,"B_NoneType",UNASSIGNED,($SuperG_class)&B_valueG_methods,(void (*)(B_NoneType))$default__init__,                                            B_NoneTypeD__serialize__,  B_NoneTypeD__deserialize__, B_NoneTypeD__bool__, B_NoneTypeD__str__, B_NoneTypeD__str__};
diff --git a/builtin/none.h b/builtin/none.h
index 3796d69c4..103fab030 100644
--- a/builtin/none.h
+++ b/builtin/none.h
@@ -1,5 +1,6 @@
 struct B_NoneTypeG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(B_NoneType);
@@ -13,6 +14,7 @@ struct B_NoneTypeG_class {
 struct B_NoneType {
     struct B_NoneTypeG_class *$class;
 };
+extern GC_word B_NoneTypeD_gcbm[GC_BITMAP_SIZE(struct B_NoneType)];
 
 extern struct B_NoneTypeG_class B_NoneTypeG_methods;
 B_NoneType B_NoneTypeG_new();
diff --git a/builtin/range.c b/builtin/range.c
index 3b8e57120..331335f22 100644
--- a/builtin/range.c
+++ b/builtin/range.c
@@ -103,6 +103,7 @@ B_IteratorB_range B_IteratorB_range$_deserialize(B_IteratorB_range self, $Serial
 }
 
 struct B_IteratorB_rangeG_class B_IteratorB_rangeG_methods = {
+    0,
     "B_IteratorB_range",
     UNASSIGNED,
     ($SuperG_class)&B_IteratorG_methods,
diff --git a/builtin/range.h b/builtin/range.h
index 3ca93e9fd..e85bef69a 100644
--- a/builtin/range.h
+++ b/builtin/range.h
@@ -5,13 +5,15 @@ struct B_range {
     long stop;
     long step;
 };
+extern GC_word B_rangeD_gcbm[GC_BITMAP_SIZE(struct B_range)];
 
 // Iterators over ranges ///////////////////////////////////////////////////////
 
 typedef struct B_IteratorB_range *B_IteratorB_range;
 
 struct B_IteratorB_rangeG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(B_IteratorB_range, B_range);
@@ -28,6 +30,7 @@ struct B_IteratorB_range {
     B_range src;
     int nxt;
 };
+extern GC_word B_IteratorB_rangeD_gcbm[GC_BITMAP_SIZE(struct B_IteratorB_range)];
 
 extern struct B_IteratorB_rangeG_class  B_IteratorB_rangeG_methods;
 B_IteratorB_range B_IteratorB_rangeG_new(B_range);
diff --git a/builtin/serialization_tests/ActorRing.c b/builtin/serialization_tests/ActorRing.c
index 1de9f3f42..61559262a 100644
--- a/builtin/serialization_tests/ActorRing.c
+++ b/builtin/serialization_tests/ActorRing.c
@@ -45,6 +45,7 @@ lambda$1 lambda$1D___deserialize__(B_NoneType state) {
 }
 
 struct lambda$1G_class lambda$1G_methods = {
+    0,
     "lambda$1",
     UNASSIGNED,
     NULL,
@@ -94,6 +95,7 @@ lambda$2 lambda$2D___deserialize__(B_NoneType state) {
 }
 
 struct lambda$2G_class lambda$2G_methods = {
+    0,
     "lambda$2",
     UNASSIGNED,
     NULL,
@@ -160,6 +162,7 @@ Act ActD___deserialize__(B_NoneType state) {
 }
 
 struct ActG_class ActG_methods = {
+    0,
     "Act",
     UNASSIGNED,
     NULL,
@@ -209,6 +212,7 @@ lambda$3 lambda$3D___deserialize__(B_NoneType state) {
 }
 
 struct lambda$3G_class lambda$3G_methods = {
+    0,
     "lambda$3",
     UNASSIGNED,
     NULL,
@@ -251,6 +255,7 @@ lambda$4 lambda$4D___deserialize__(B_NoneType state) {
 }
 
 struct lambda$4G_class lambda$4G_methods = {
+    0,
     "lambda$4",
     UNASSIGNED,
     NULL,
@@ -311,6 +316,7 @@ Root RootD___deserialize__(B_NoneType state) {
 }
 
 struct RootG_class RootG_methods = {
+    0,
     "Root",
     UNASSIGNED,
     NULL,
@@ -322,7 +328,7 @@ struct RootG_class RootG_methods = {
 };
 
 $R RootG_new(B_Env env, $Cont cont) {
-    Root $tmp = malloc(sizeof(struct Root));
+    Root $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct Root), RootG_methods.$GCdescr);
     $tmp->$class = &RootG_methods;
     return RootG_methods.__init__($tmp, env, $CONSTCONT($tmp, cont));
 }
diff --git a/builtin/serialization_tests/ActorRing.h b/builtin/serialization_tests/ActorRing.h
index ea31ae546..1f5422b05 100644
--- a/builtin/serialization_tests/ActorRing.h
+++ b/builtin/serialization_tests/ActorRing.h
@@ -19,7 +19,8 @@ typedef struct lambda$4 *lambda$4;
 typedef struct Root *Root;
 
 struct lambda$1G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(lambda$1, $Cont);
@@ -33,9 +34,11 @@ struct lambda$1 {
     struct lambda$1G_class *$class;
     $Cont cont$0;    
 };
+extern GC_word lambda$1D_gcbm[GC_BITMAP_SIZE(struct lambda$1)];
 
 struct lambda$2G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(lambda$2, Act, B_int, B_list);
@@ -51,9 +54,11 @@ struct lambda$2 {
     B_int from;
     B_list table;
 };
+extern GC_word lambda$2D_gcbm[GC_BITMAP_SIZE(struct lambda$2)];
 
 struct ActG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     $R (*__init__)(Act, B_int, $Cont);
@@ -74,9 +79,11 @@ struct Act {
     B_dict rcv_dict;
     B_dict snd_dict;
 };
+extern GC_word ActD_gcbm[GC_BITMAP_SIZE(struct Act)];
 
 struct lambda$3G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(lambda$3, Root, B_Iterator, $Cont);
@@ -92,9 +99,11 @@ struct lambda$3 {
     B_Iterator iter$1;
     $Cont cont$0;
 };
+extern GC_word lambda$3D_gcbm[GC_BITMAP_SIZE(struct lambda$3)];
 
 struct lambda$4G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(lambda$4, $Cont);
@@ -108,9 +117,11 @@ struct lambda$4 {
     struct lambda$4G_class *$class;
     $Cont cont$0;
 };
+extern GC_word lambda$4D_gcbm[GC_BITMAP_SIZE(struct lambda$4)];
 
 struct RootG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     $R (*__init__)(Root, B_Env, $Cont);
@@ -126,6 +137,7 @@ struct Root {
     };
     B_list table;
 };
+extern GC_word RootD_gcbm[GC_BITMAP_SIZE(struct Root)];
 
 $R loop$1(Root, B_Iterator, $Cont, $WORD);
 $R cont$1(Root, B_Iterator, $Cont, Act);
diff --git a/builtin/serialization_tests/graph.c b/builtin/serialization_tests/graph.c
index 70a8fcb56..4a179a289 100644
--- a/builtin/serialization_tests/graph.c
+++ b/builtin/serialization_tests/graph.c
@@ -38,8 +38,7 @@ B_str $Node__str__($Node self) {
   return res;                                        
 }
 
-struct $NodeG_class $NodeG_methods = {"",UNASSIGNED,NULL,$Node__init__,$Node__serialize__,$Node__deserialize__,$Node__bool__,$Node__str__};
-
+struct $NodeG_class $NodeG_methods = {0,"",UNASSIGNED,NULL,$Node__init__,$Node__serialize__,$Node__deserialize__,$Node__bool__,$Node__str__};
 // IntNodes (graph vertices) ////////////////////////////////////////////////////////////////////////////
  
 void $IntNode__init__($IntNode self, B_list nbors, B_int ival) {
@@ -67,8 +66,7 @@ void $IntNode__serialize__($IntNode self,B_NoneType state) {
   return res;
 }
 
-struct $IntNodeG_class $IntNodeG_methods = {"",UNASSIGNED,NULL,$IntNode__init__,$IntNode__serialize__,$IntNode__deserialize__,$IntNode__bool__,$IntNode__str__};
-
+struct $IntNodeG_class $IntNodeG_methods = {0,"",UNASSIGNED,NULL,$IntNode__init__,$IntNode__serialize__,$IntNode__deserialize__,$IntNode__bool__,$IntNode__str__};
 
 // FloatNodes (graph vertices) ////////////////////////////////////////////////////////////////////////////
 
@@ -97,8 +95,7 @@ void $FloatNode__serialize__($FloatNode self,B_NoneType state) {
   return res;
 }
 
-struct $FloatNodeG_class $FloatNodeG_methods = {"",UNASSIGNED,NULL,$FloatNode__init__,$FloatNode__serialize__,$FloatNode__deserialize__,$FloatNode__bool__,$FloatNode__str__};
-
+struct $FloatNodeG_class $FloatNodeG_methods = {0,"",UNASSIGNED,NULL,$FloatNode__init__,$FloatNode__serialize__,$FloatNode__deserialize__,$FloatNode__bool__,$FloatNode__str__};
 
 // Graphs ////////////////////////////////////////////////////////////////////////////
 
@@ -125,8 +122,7 @@ void $Graph__serialize__($Graph self, B_NoneType state) {
   return res;
 }
 
-struct $GraphG_class $GraphG_methods = {"",UNASSIGNED,NULL,$Graph__init__,$Graph__serialize__,$Graph__deserialize__,$Graph__bool__,$Graph__str__};
-
+struct $GraphG_class $GraphG_methods = {0,"",UNASSIGNED,NULL,$Graph__init__,$Graph__serialize__,$Graph__deserialize__,$Graph__bool__,$Graph__str__};
 void $register_graph(){
   $register(&$NodeG_methods);
   $register(&$IntNodeG_methods);
diff --git a/builtin/serialization_tests/graph.h b/builtin/serialization_tests/graph.h
index 1f545e62d..5123be234 100644
--- a/builtin/serialization_tests/graph.h
+++ b/builtin/serialization_tests/graph.h
@@ -7,7 +7,8 @@ struct $Node;
 typedef struct $Node *$Node;
 
 struct $NodeG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($Node, B_list);
@@ -21,6 +22,7 @@ struct $Node {
   struct $NodeG_class *$class;
   B_list nbors; // list of Nodes
 };
+extern GC_word $NodeD_gcbm[GC_BITMAP_SIZE(struct $Node)];
 
 extern struct $NodeG_class $NodeG_methods;
 
@@ -31,7 +33,8 @@ struct $IntNode;
 typedef struct $IntNode *$IntNode;
 
 struct $IntNodeG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($IntNode, B_list, B_int);
@@ -46,6 +49,7 @@ struct $IntNode {
   B_list nbors; // list of Nodes
   B_int ival;
 };
+extern GC_word $IntNodeD_gcbm[GC_BITMAP_SIZE(struct $IntNode)];
 
 extern struct $IntNodeG_class $IntNodeG_methods;
 
@@ -56,7 +60,8 @@ struct $FloatNode;
 typedef struct $FloatNode *$FloatNode;
 
 struct $FloatNodeG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($FloatNode, B_list, B_float);
@@ -71,6 +76,7 @@ struct $FloatNode {
   B_list nbors; // list of Nodes
   B_float fval;
 };
+extern GC_word $FloatNodeD_gcbm[GC_BITMAP_SIZE(struct $FloatNode)];
 
 extern struct $FloatNodeG_class $FloatNodeG_methods;
 
@@ -79,7 +85,8 @@ extern struct $FloatNodeG_class $FloatNodeG_methods;
 typedef struct $Graph *$Graph;
 
 struct $GraphG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($Graph, B_list);
@@ -93,6 +100,7 @@ struct $Graph {
   struct $GraphG_class *$class;
   B_list nodes; 
 };
+extern GC_word $GraphD_gcbm[GC_BITMAP_SIZE(struct $Graph)];
 
 extern struct $GraphG_class $GraphG_methods;
 
diff --git a/builtin/serialize.c b/builtin/serialize.c
index 752355219..8ab8b1155 100644
--- a/builtin/serialize.c
+++ b/builtin/serialize.c
@@ -54,6 +54,7 @@ B_int B_HashableD_WORD_hash(B_HashableD_WORD wit, $WORD a) {
 }
 
 struct B_HashableD_WORDG_class B_HashableD_WORDG_methods = {
+    0,
     "B_HashableD_WORD",
     UNASSIGNED,
     ($SuperG_class)&B_HashableG_methods,
diff --git a/builtin/serialize.h b/builtin/serialize.h
index 6d818e4be..04d6107b1 100644
--- a/builtin/serialize.h
+++ b/builtin/serialize.h
@@ -23,13 +23,15 @@ struct $ROWLISTHEADER {
 //typedef struct $Serial$state *$Serial$state;
 
 struct $Serial$state {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     B_dict done;
     $WORD (*globmap)($WORD);
     long row_no;
     $ROW row;
     $ROW fst; //not used in deserialization
 };
+extern GC_word $Serial$stateD_gcbm[GC_BITMAP_SIZE(struct $Serial$state)];
 
 // small-step helpers for defining serializations //////////////////////////////////////////////////
 
@@ -64,7 +66,8 @@ void $serialize_file($Serializable s, char *file);
 typedef struct B_HashableD_WORD *B_HashableD_WORD;
 
 struct B_HashableD_WORDG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class superclass;
     void (*__init__)(B_HashableD_WORD);
@@ -81,6 +84,7 @@ struct B_HashableD_WORDG_class {
 struct B_HashableD_WORD {
     struct B_HashableD_WORDG_class *$class;
 };
+extern GC_word B_HashableD_WORDD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_WORD)];
 
 extern struct B_HashableD_WORDG_class B_HashableD_WORDG_methods;
 B_HashableD_WORD B_HashableD_WORDG_new();
diff --git a/builtin/set.c b/builtin/set.c
index 6a14e5be4..69ca34330 100644
--- a/builtin/set.c
+++ b/builtin/set.c
@@ -353,8 +353,7 @@ B_IteratorD_set B_IteratorD_setD__deserialize(B_IteratorD_set res, $Serial$state
     return res;
 }
 
-struct B_IteratorD_setG_class B_IteratorD_setG_methods = {"B_IteratorD_set",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_set_init,
-                                                    B_IteratorD_set_serialize, B_IteratorD_setD__deserialize,B_IteratorD_set_bool,B_IteratorD_set_str,B_IteratorD_set_str, B_IteratorD_set_next};
+struct B_IteratorD_setG_class B_IteratorD_setG_methods = {0,"B_IteratorD_set",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorD_set_init,                                                    B_IteratorD_set_serialize, B_IteratorD_setD__deserialize,B_IteratorD_set_bool,B_IteratorD_set_str,B_IteratorD_set_str, B_IteratorD_set_next};
 
 
 B_Iterator B_SetD_setD___iter__ (B_SetD_set wit, B_set set) {
diff --git a/builtin/set.h b/builtin/set.h
index 6e87a298c..580650c8b 100644
--- a/builtin/set.h
+++ b/builtin/set.h
@@ -12,6 +12,7 @@ struct B_set {
     long finger;                       // Search finger for pop() 
     B_setentry *table;                  // the hashtable
 };
+extern GC_word B_setD_gcbm[GC_BITMAP_SIZE(struct B_set)];
 
 
 // Iterators over sets ///////////////////////////////////////////////////////
@@ -19,7 +20,8 @@ struct B_set {
 typedef struct B_IteratorD_set *B_IteratorD_set; ;
 
 struct B_IteratorD_setG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(B_IteratorD_set, B_set);
@@ -36,6 +38,7 @@ struct B_IteratorD_set {
     B_set src;
     int nxt;
 };
+extern GC_word B_IteratorD_setD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_set)];
 
 extern struct  B_IteratorD_setG_class  B_IteratorD_setG_methods;
 B_IteratorD_set B_IteratorD_setG_new(B_set);
diff --git a/builtin/slice.h b/builtin/slice.h
index 92f636e4b..c0f405ee1 100644
--- a/builtin/slice.h
+++ b/builtin/slice.h
@@ -5,5 +5,6 @@ struct B_slice {
   long *stop;
   long *step;
 };
+extern GC_word B_sliceD_gcbm[GC_BITMAP_SIZE(struct B_slice)];
 
 void normalize_slice(B_slice slc, long len, long *slen, long *start, long *stop, long *step);
diff --git a/builtin/str.c b/builtin/str.c
index 5bb6f8df9..f204a3631 100644
--- a/builtin/str.c
+++ b/builtin/str.c
@@ -1256,8 +1256,7 @@ static B_str B_IteratorB_strD_next(B_IteratorB_str self) {
 }
 
 
-struct B_IteratorB_strG_class B_IteratorB_strG_methods = {"B_IteratorB_str",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorB_strD_init,
-                                                    B_IteratorB_strD_serialize, B_IteratorB_str$_deserialize,
+struct B_IteratorB_strG_class B_IteratorB_strG_methods = {0,"B_IteratorB_str",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorB_strD_init,                                                    B_IteratorB_strD_serialize, B_IteratorB_str$_deserialize,
                                                     B_IteratorB_strD_bool, B_IteratorB_strD_str, B_IteratorB_strD_str, B_IteratorB_strD_next};
 
 // now, define __iter__
@@ -2085,6 +2084,7 @@ B_IteratorB_bytearray B_IteratorB_bytearray$_deserialize(B_IteratorB_bytearray r
 }
 
 struct B_IteratorB_bytearrayG_class B_IteratorB_bytearrayG_methods = {
+    0,
     "",
     UNASSIGNED,
     ($SuperG_class)&B_IteratorG_methods,
@@ -3097,8 +3097,7 @@ static B_int B_IteratorB_bytesD_next(B_IteratorB_bytes self) {
     return self->nxt >= self->src->nbytes ? NULL : to$int(self->src->str[self->nxt++]);
 }
 
-struct B_IteratorB_bytesG_class B_IteratorB_bytesG_methods = {"B_IteratorB_bytes",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorB_bytesD_init,
-                                                        B_IteratorB_bytesD_serialize, B_IteratorB_bytes$_deserialize,
+struct B_IteratorB_bytesG_class B_IteratorB_bytesG_methods = {0,"B_IteratorB_bytes",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, B_IteratorB_bytesD_init,                                                        B_IteratorB_bytesD_serialize, B_IteratorB_bytes$_deserialize,
                                                         B_IteratorB_bytesD_bool, B_IteratorB_bytesD_str,  B_IteratorB_bytesD_str, B_IteratorB_bytesD_next};
 
 B_Iterator B_ContainerD_bytesD___iter__ (B_ContainerD_bytes wit, B_bytes str) {
@@ -3368,7 +3367,7 @@ B_str B_strD_join_par(char lpar, B_list elems, char rpar) {
 
 B_str $default__str__(B_value self) {
     char *s;
-    asprintf(&s,"<%s object at %p>",self->$class->$GCINFO,self);
+    asprintf(&s,"<%s object at %p>",self->$class->$name,self);
     return to$str(s);
 }
 
diff --git a/builtin/str.h b/builtin/str.h
index 5b3ab1232..eb65a7b6b 100644
--- a/builtin/str.h
+++ b/builtin/str.h
@@ -6,6 +6,7 @@ struct B_str {
     int nchars;              // length of str in Unicode chars
     unsigned char *str;      // str is UTF-8 encoded.
 };
+extern GC_word B_strD_gcbm[GC_BITMAP_SIZE(struct B_str)];
 
 // Constructor; str must be a null-terminated, correctly UTF-8-encoded string.
 // The constructor checks this and returns a B_str value.
@@ -18,7 +19,8 @@ unsigned char *fromB_str(B_str str);
 typedef struct B_IteratorB_str *B_IteratorB_str; ;
 
 struct B_IteratorB_strG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(B_IteratorB_str, B_str);
@@ -35,6 +37,7 @@ struct B_IteratorB_str {
     B_str src;
     int nxt;
 };
+extern GC_word B_IteratorB_strD_gcbm[GC_BITMAP_SIZE(struct B_IteratorB_str)];
 
 extern struct  B_IteratorB_strG_class  B_IteratorB_strG_methods;
 B_IteratorB_str B_IteratorB_strG_new(B_str);
@@ -49,6 +52,7 @@ struct B_bytearray {
     unsigned char *str;
     int capacity;
 };
+extern GC_word B_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_bytearray)];
 
  
 B_bytearray toB_bytearray(char *str); 
@@ -59,7 +63,8 @@ unsigned char *fromB_bytearray(B_bytearray b);
 typedef struct B_IteratorB_bytearray *B_IteratorB_bytearray; ;
 
 struct B_IteratorB_bytearrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(B_IteratorB_bytearray, B_bytearray);
@@ -76,6 +81,7 @@ struct B_IteratorB_bytearray {
     B_bytearray src;
     int nxt;
 };
+extern GC_word B_IteratorB_bytearrayD_gcbm[GC_BITMAP_SIZE(struct B_IteratorB_bytearray)];
 
 extern struct  B_IteratorB_bytearrayG_class  B_IteratorB_bytearrayG_methods;
 B_IteratorB_bytearray B_IteratorB_bytearrayG_new(B_bytearray);
@@ -88,6 +94,7 @@ struct B_bytes {
     int nbytes;
     unsigned char *str;
 };
+extern GC_word B_bytesD_gcbm[GC_BITMAP_SIZE(struct B_bytes)];
 
 B_bytes to$bytes(char *str);
 B_bytes to$bytesD_len(char *str, int len);
@@ -100,7 +107,8 @@ unsigned char *fromB_bytes(B_bytes b);
 typedef struct B_IteratorB_bytes *B_IteratorB_bytes; ;
 
 struct B_IteratorB_bytesG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(B_IteratorB_bytes, B_bytes);
@@ -117,6 +125,7 @@ struct B_IteratorB_bytes {
     B_bytes src;
     int nxt;
 };
+extern GC_word B_IteratorB_bytesD_gcbm[GC_BITMAP_SIZE(struct B_IteratorB_bytes)];
 
 extern struct  B_IteratorB_bytesG_class  B_IteratorB_bytesG_methods;
 B_IteratorB_bytes B_IteratorB_bytesG_new(B_bytes);
diff --git a/builtin/tests/Pingpong.c b/builtin/tests/Pingpong.c
index 5ef0da095..c5d7c80f4 100644
--- a/builtin/tests/Pingpong.c
+++ b/builtin/tests/Pingpong.c
@@ -82,6 +82,7 @@ Pingpong PingpongD___deserialize__(B_NoneType state) {
 }
 
 struct lambda$1G_class lambda$1G_methods = {
+    0,
     "lambda$1",
     NULL,
     lambda$1D___init__,
@@ -90,6 +91,7 @@ struct lambda$1G_class lambda$1G_methods = {
     lambda$1D___call__
 };
 struct lambda$2G_class lambda$2G_methods = {
+    0,
     "lambda$2",
     NULL,
     lambda$2D___init__,
@@ -98,6 +100,7 @@ struct lambda$2G_class lambda$2G_methods = {
     lambda$2D___call__
 };
 struct PingpongG_class PingpongG_methods = {
+    0,
     "Pingpong",
     NULL,
     PingpongD___init__,
@@ -108,7 +111,7 @@ struct PingpongG_class PingpongG_methods = {
 };
 
 $R PingpongG_new(B_Env env, $Cont cont) {
-    Pingpong $tmp = malloc(sizeof(struct Pingpong));
+    Pingpong $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct Pingpong), PingpongG_methods.$GCdescr);
     $tmp->$class = &PingpongG_methods;
     return PingpongG_methods.__init__($tmp, env, $CONSTCONT($tmp, cont));
 }
diff --git a/builtin/tests/Pingpong.h b/builtin/tests/Pingpong.h
index f79442e3b..e33eef484 100644
--- a/builtin/tests/Pingpong.h
+++ b/builtin/tests/Pingpong.h
@@ -13,7 +13,8 @@ typedef struct lambda$2 *lambda$2;
 typedef struct Pingpong *Pingpong;
 
 struct lambda$1G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     $SuperG_class $superclass;
     void (*__init__)(lambda$1, Pingpong, B_int);
     void (*__serialize__)(lambda$1, B_NoneType);
@@ -28,9 +29,11 @@ struct lambda$1 {
     Pingpong self;
     B_int count;
 };
+extern GC_word lambda$1D_gcbm[GC_BITMAP_SIZE(struct lambda$1)];
 
 struct lambda$2G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     $SuperG_class $superclass;
     void (*__init__)(lambda$2, Pingpong);
     void (*__serialize__)(lambda$2, B_NoneType);
@@ -44,9 +47,11 @@ struct lambda$2 {
     };
     Pingpong self;
 };
+extern GC_word lambda$2D_gcbm[GC_BITMAP_SIZE(struct lambda$2)];
 
 struct PingpongG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     $SuperG_class $superclass;
     $R (*__init__)(Pingpong, B_Env, $Cont);
     void (*__serialize__)(Pingpong, B_NoneType);
@@ -62,6 +67,7 @@ struct Pingpong {
     B_int i;
     B_int count;
 };
+extern GC_word PingpongD_gcbm[GC_BITMAP_SIZE(struct Pingpong)];
 
 extern struct lambda$1G_class lambda$1G_methods;
 extern struct lambda$2G_class lambda$2G_methods;
diff --git a/builtin/tuple.c b/builtin/tuple.c
index a924ce265..2079de827 100644
--- a/builtin/tuple.c
+++ b/builtin/tuple.c
@@ -74,6 +74,7 @@ B_tuple B_tupleD___deserialize__(B_tuple self, $Serial$state state) {
 }
 
 struct B_tupleG_class B_tupleG_methods = {
+    0,
     "tuple",
     UNASSIGNED,
     ($SuperG_class)&B_valueG_methods,
@@ -118,8 +119,7 @@ B_IteratorD_tuple B_IteratorD_tuple$_deserialize(B_IteratorD_tuple res, $Serial$
     return res;
 }
 
-struct B_IteratorD_tupleG_class B_IteratorD_tupleG_methods = {"B_IteratorD_tuple",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_tupleD_init,
-                                                        B_IteratorD_tupleD_serialize,B_IteratorD_tuple$_deserialize,B_IteratorD_tupleD_bool,B_IteratorD_tupleD_str,B_IteratorD_tupleD_str,B_IteratorD_tupleD_next};
+struct B_IteratorD_tupleG_class B_IteratorD_tupleG_methods = {0,"B_IteratorD_tuple",UNASSIGNED,($SuperG_class)&B_IteratorG_methods,B_IteratorD_tupleD_init,                                                        B_IteratorD_tupleD_serialize,B_IteratorD_tuple$_deserialize,B_IteratorD_tupleD_bool,B_IteratorD_tupleD_str,B_IteratorD_tupleD_str,B_IteratorD_tupleD_next};
 
 
 // Iterable ///////////////////////////////////////////////////////////////
@@ -140,6 +140,7 @@ B_IterableD_tuple B_IterableD_tupleD___deserialize__(B_IterableD_tuple self, $Se
     return res;
 }
 struct B_IterableD_tupleG_class B_IterableD_tupleG_methods = {
+    0,
     "B_IterableD_tuple",
     UNASSIGNED,
     ($SuperG_class)&B_IterableG_methods,
@@ -219,6 +220,7 @@ B_NoneType B_SliceableD_tupleD___delslice__ (B_SliceableD_tuple wit, B_tuple sel
 }
 
 struct B_SliceableD_tupleG_class B_SliceableD_tupleG_methods = {
+    0,
     "B_SliceableD_tuple",
     UNASSIGNED,
     ($SuperG_class)&B_SliceableG_methods,
@@ -274,6 +276,7 @@ B_int B_HashableD_tupleD___hash__ (B_HashableD_tuple wit, B_tuple tup) {
 }
 
 struct B_HashableD_tupleG_class B_HashableD_tupleG_methods = {
+    0,
     "B_HashableD_tuple",
     UNASSIGNED,
     ($SuperG_class)&B_HashableG_methods,
diff --git a/builtin/tuple.h b/builtin/tuple.h
index f0f86d81b..b8a0a5e9e 100644
--- a/builtin/tuple.h
+++ b/builtin/tuple.h
@@ -1,5 +1,6 @@
 struct B_tupleG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(B_tuple,int,...);
@@ -15,6 +16,7 @@ struct B_tuple {
     int size;
     $WORD *components;
 };
+extern GC_word B_tupleD_gcbm[GC_BITMAP_SIZE(struct B_tuple)];
 
 extern struct B_tupleG_class B_tupleG_methods;
 B_tuple B_tupleG_new(int,...);
@@ -57,9 +59,11 @@ typedef struct B_HashableD_tupleG_class *B_HashableD_tupleG_class;
 struct B_IterableD_tuple {
     B_IterableD_tupleG_class $class;
 };
+extern GC_word B_IterableD_tupleD_gcbm[GC_BITMAP_SIZE(struct B_IterableD_tuple)];
 
 struct B_IterableD_tupleG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(B_IterableD_tuple);
@@ -86,9 +90,11 @@ B_IterableD_tuple B_IterableD_tupleG_new();
 struct B_SliceableD_tuple {
     B_SliceableD_tupleG_class $class;
 };
+extern GC_word B_SliceableD_tupleD_gcbm[GC_BITMAP_SIZE(struct B_SliceableD_tuple)];
 
 struct B_SliceableD_tupleG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(B_SliceableD_tuple);
@@ -125,9 +131,11 @@ struct B_HashableD_tuple {
     int W_HashableB_tuple$size;
     B_Hashable *W_Hashable;
 };
+extern GC_word B_HashableD_tupleD_gcbm[GC_BITMAP_SIZE(struct B_HashableD_tuple)];
 
 struct B_HashableD_tupleG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(B_HashableD_tuple,int,B_Hashable*);
@@ -165,7 +173,8 @@ extern struct B_HashableD_tuple *B_HashableD_tuple_new(int,B_Hashable*);
 typedef struct B_IteratorD_tuple *B_IteratorD_tuple;
 
 struct B_IteratorD_tupleG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(B_IteratorD_tuple, B_tuple);
@@ -182,6 +191,7 @@ struct B_IteratorD_tuple {
     B_tuple src;
     int nxt;
 };
+extern GC_word B_IteratorD_tupleD_gcbm[GC_BITMAP_SIZE(struct B_IteratorD_tuple)];
 
 extern struct B_IteratorD_tupleG_class B_IteratorD_tupleG_methods;
 B_IteratorD_tuple B_IteratorD_tupleG_new(B_tuple);
diff --git a/builtin/u16.h b/builtin/u16.h
index 5b3929720..c4926ecbd 100644
--- a/builtin/u16.h
+++ b/builtin/u16.h
@@ -2,6 +2,7 @@ struct B_u16 {
     struct B_u16G_class *$class;
     unsigned short val;
 };
+extern GC_word B_u16D_gcbm[GC_BITMAP_SIZE(struct B_u16)];
 
 B_u16 toB_u16(unsigned short n);
 unsigned short fromB_u16(B_u16 n);
diff --git a/builtin/u32.h b/builtin/u32.h
index 0c1490b22..75d8a4c01 100644
--- a/builtin/u32.h
+++ b/builtin/u32.h
@@ -2,6 +2,7 @@ struct B_u32 {
     struct B_u32G_class *$class;
     unsigned int val;
 };
+extern GC_word B_u32D_gcbm[GC_BITMAP_SIZE(struct B_u32)];
 
 B_u32 toB_u32(unsigned int n);
 unsigned int fromB_u32(B_u32 n);
diff --git a/builtin/u64.h b/builtin/u64.h
index 2582053b5..e413985ac 100644
--- a/builtin/u64.h
+++ b/builtin/u64.h
@@ -2,6 +2,7 @@ struct B_u64 {
     struct B_u64G_class *$class;
     unsigned long val;
 };
+extern GC_word B_u64D_gcbm[GC_BITMAP_SIZE(struct B_u64)];
 
 B_u64 toB_u64(unsigned long n);
 unsigned long fromB_u64(B_u64 n);
diff --git a/rts/pingpong.c b/rts/pingpong.c
index a2ac0df14..05cdb1de6 100644
--- a/rts/pingpong.c
+++ b/rts/pingpong.c
@@ -200,6 +200,7 @@ Pingpong PingpongD___deserialize__(Pingpong res, B_NoneType state) {
 ////////////////////////////////////////////////////////////////////////////////////////
 
 struct lambda$1G_class lambda$1G_methods = {
+    0,
     "lambda$1",
     UNASSIGNED,
     ($SuperG_class)&$ContG_methods,
@@ -211,6 +212,7 @@ struct lambda$1G_class lambda$1G_methods = {
     lambda$1D___call__
 };
 struct lambda$2G_class lambda$2G_methods = {
+    0,
     "lambda$2",
     UNASSIGNED,
     ($SuperG_class)&$ContG_methods,
@@ -222,6 +224,7 @@ struct lambda$2G_class lambda$2G_methods = {
     lambda$2D___call__
 };
 struct lambda$3G_class lambda$3G_methods = {
+    0,
     "lambda$3",
     UNASSIGNED,
     ($SuperG_class)&$ContG_methods,
@@ -233,6 +236,7 @@ struct lambda$3G_class lambda$3G_methods = {
     lambda$3D___call__
 };
 struct PingpongG_class PingpongG_methods = {
+    0,
     "Pingpong",
     UNASSIGNED,
     ($SuperG_class)&$ActorG_methods,
diff --git a/rts/pingpong.h b/rts/pingpong.h
index 5909e3888..47f45fed5 100644
--- a/rts/pingpong.h
+++ b/rts/pingpong.h
@@ -13,7 +13,8 @@ typedef struct lambda$3 *lambda$3;
 typedef struct Pingpong *Pingpong;
 
 struct lambda$1G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(lambda$1, Pingpong, B_int, B_int);
@@ -29,10 +30,12 @@ struct lambda$1 {
     B_int count;
     B_int q;
 };
+extern GC_word lambda$1D_gcbm[GC_BITMAP_SIZE(struct lambda$1)];
 lambda$1 lambda$1G_new(Pingpong, B_int, B_int);
 
 struct lambda$2G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(lambda$2, Pingpong, B_int);
@@ -47,10 +50,12 @@ struct lambda$2 {
     Pingpong self;
     B_int q;
 };
+extern GC_word lambda$2D_gcbm[GC_BITMAP_SIZE(struct lambda$2)];
 lambda$2 lambda$2G_new(Pingpong, B_int);
 
 struct lambda$3G_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(lambda$3, $Cont);
@@ -64,10 +69,12 @@ struct lambda$3 {
     struct lambda$3G_class *$class;
     $Cont cont;
 };
+extern GC_word lambda$3D_gcbm[GC_BITMAP_SIZE(struct lambda$3)];
 lambda$3 lambda$3G_new($Cont);
 
 struct PingpongG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     $R (*__init__)(Pingpong, B_int, $Cont);
@@ -92,6 +99,7 @@ struct Pingpong {
     B_int i;
     B_int count;
 };
+extern GC_word PingpongD_gcbm[GC_BITMAP_SIZE(struct Pingpong)];
 $R PingpongG_new(B_int, $Cont);
 
 extern struct lambda$1G_class lambda$1G_methods;
diff --git a/rts/rts.c b/rts/rts.c
index 43b4e1dd3..0f4f2aece 100644
--- a/rts/rts.c
+++ b/rts/rts.c
@@ -230,7 +230,7 @@ pthread_cond_t rts_exit_signal = PTHREAD_COND_INITIALIZER;
 void pin_actor_affinity() {
     $Actor a = ($Actor)pthread_getspecific(self_key);
     int i = (int)pthread_getspecific(pkey_wtid);
-    log_debug("Pinning affinity for %s actor %ld to current WT %d", a->$class->$GCINFO, a->$globkey, i);
+    log_debug("Pinning affinity for %s actor %ld to current WT %d", a->$class->$name, a->$globkey, i);
     a->$affinity = i;
 }
 
@@ -348,7 +348,7 @@ void $ActorD___init__($Actor a) {
     atomic_flag_clear(&a->B_Msg_lock);
     a->$globkey = get_next_key();
     a->$affinity = 0;
-    rtsd_printf("# New Actor %ld at %p of class %s", a->$globkey, a, a->$class->$GCINFO);
+    rtsd_printf("# New Actor %ld at %p of class %s", a->$globkey, a, a->$class->$name);
 }
 
 B_bool $ActorD___bool__($Actor self) {
@@ -357,7 +357,7 @@ B_bool $ActorD___bool__($Actor self) {
 
 B_str $ActorD___str__($Actor self) {
   char *s;
-  asprintf(&s,"<$Actor %ld %s at %p>", self->$globkey, self->$class->$GCINFO, self);
+  asprintf(&s,"<$Actor %ld %s at %p>", self->$globkey, self->$class->$name, self);
   return to$str(s);
 }
 
@@ -463,6 +463,7 @@ void $ConstContD___serialize__($ConstCont self, $Serial$state state) {
 ////////////////////////////////////////////////////////////////////////////////////////
 
 struct B_MsgG_class B_MsgG_methods = {
+    0,
     MSG_HEADER,
     UNASSIGNED,
     NULL,
@@ -475,6 +476,7 @@ struct B_MsgG_class B_MsgG_methods = {
 };
 
 struct $ActorG_class $ActorG_methods = {
+    0,
     ACTOR_HEADER,
     UNASSIGNED,
     NULL,
@@ -488,6 +490,7 @@ struct $ActorG_class $ActorG_methods = {
 };
 
 struct $CatcherG_class $CatcherG_methods = {
+    0,
     CATCHER_HEADER,
     UNASSIGNED,
     NULL,
@@ -500,6 +503,7 @@ struct $CatcherG_class $CatcherG_methods = {
 };
 
 struct $ConstContG_class $ConstContG_methods = {
+    0,
     "$ConstCont",
     UNASSIGNED,
     NULL,
@@ -703,6 +707,7 @@ void $Done__serialize__($Cont self, $Serial$state state) {
 }
 
 struct $ContG_class $DoneG_methods = {
+    0,
     "$Done",
     UNASSIGNED,
     NULL,
@@ -743,6 +748,7 @@ void $Fail__serialize__($Cont self, $Serial$state state) {
 }
 
 struct $ContG_class $FailG_methods = {
+    0,
     "$Fail",
     UNASSIGNED,
     NULL,
@@ -764,6 +770,7 @@ struct $Cont $Fail$instance = {
 }
 
 struct $ContG_class $InitRootG_methods = {
+    0,
     "$InitRoot",
     UNASSIGNED,
     NULL,
@@ -1163,7 +1170,7 @@ void deserialize_system(snode_t *actors_start) {
             B_Msg msg = (B_Msg)$GET_METHODS(head->class_id)->__deserialize__(NULL, NULL);
             msg->$globkey = key;
             B_dictD_setitem(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), msg);
-            rtsd_printf("# Allocated Msg %p = %ld of class %s = %d", msg, msg->$globkey, msg->$class->$GCINFO, msg->$class->$class_id);
+            rtsd_printf("# Allocated Msg %p = %ld of class %s = %d", msg, msg->$globkey, msg->$class->$name, msg->$class->$class_id);
             if (key < min_key)
                 min_key = key;
         }
@@ -1180,7 +1187,7 @@ void deserialize_system(snode_t *actors_start) {
             $Actor act = ($Actor)$GET_METHODS(head->class_id)->__deserialize__(NULL, NULL);
             act->$globkey = key;
             B_dictD_setitem(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), act);
-            rtsd_printf("# Allocated Actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$GCINFO, act->$class->$class_id);
+            rtsd_printf("# Allocated Actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$name, act->$class->$class_id);
             if (key < min_key)
                 min_key = key;
         }
@@ -1198,7 +1205,7 @@ void deserialize_system(snode_t *actors_start) {
             int blob_size = r2->last_blob_size;
             $ROW row = extract_row(blob, blob_size);
             B_Msg msg = (B_Msg)B_dictD_get(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), NULL);
-            rtsd_printf("####### Deserializing msg %p = %ld of class %s = %d", msg, msg->$globkey, msg->$class->$GCINFO, msg->$class->$class_id);
+            rtsd_printf("####### Deserializing msg %p = %ld of class %s = %d", msg, msg->$globkey, msg->$class->$name, msg->$class->$class_id);
             print_rows(row);
             $glob_deserialize(($Serializable)msg, row, try_globdict);
             print_msg(msg);
@@ -1215,7 +1222,7 @@ void deserialize_system(snode_t *actors_start) {
             int blob_size = r2->last_blob_size;
             $ROW row = extract_row(blob, blob_size);
             $Actor act = ($Actor)B_dictD_get(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), NULL);
-            rtsd_printf("####### Deserializing actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$GCINFO, act->$class->$class_id);
+            rtsd_printf("####### Deserializing actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$name, act->$class->$class_id);
             print_rows(row);
             $glob_deserialize(($Serializable)act, row, try_globdict);
 
@@ -1252,7 +1259,7 @@ void deserialize_system(snode_t *actors_start) {
         db_row_t* r = (db_row_t*) node->value;
         long key = (long)r->key;
         $Actor act = ($Actor)B_dictD_get(globdict, (B_Hashable)B_HashableD_intG_witness, to$int(key), NULL);
-        rtsd_printf("####### Resuming actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$GCINFO, act->$class->$class_id);
+        rtsd_printf("####### Resuming actor %p = %ld of class %s = %d", act, act->$globkey, act->$class->$name, act->$class->$class_id);
         act->$class->__resume__(act);
     }
 
@@ -1526,7 +1533,7 @@ void wt_work_cb(uv_check_t *ev) {
         clock_gettime(CLOCK_MONOTONIC, &ts1);
         wt_stats[wtid].state = WT_Working;
 
-        rtsd_printf("## Running actor %ld : %s", current->$globkey, current->$class->$GCINFO);
+        rtsd_printf("## Running actor %ld : %s", current->$globkey, current->$class->$name);
         $R r = cont->$class->__call__(cont, val);
 
         clock_gettime(CLOCK_MONOTONIC, &ts2);
@@ -1557,10 +1564,10 @@ void wt_work_cb(uv_check_t *ev) {
                 b->$waitsfor = NULL;
                 $Actor c = b->$next;
                 ENQ_ready(b);
-                rtsd_printf("## Waking up actor %ld : %s", b->$globkey, b->$class->$GCINFO);
+                rtsd_printf("## Waking up actor %ld : %s", b->$globkey, b->$class->$name);
                 b = c;
             }
-            rtsd_printf("## DONE actor %ld : %s", current->$globkey, current->$class->$GCINFO);
+            rtsd_printf("## DONE actor %ld : %s", current->$globkey, current->$class->$name);
             if (DEQ_msg(current)) {
                 ENQ_ready(current);
             }
@@ -1569,7 +1576,7 @@ void wt_work_cb(uv_check_t *ev) {
         case $RCONT: {
             m->$cont = r.cont;
             m->B_value = r.value;
-            rtsd_printf("## CONT actor %ld : %s", current->$globkey, current->$class->$GCINFO);
+            rtsd_printf("## CONT actor %ld : %s", current->$globkey, current->$class->$name);
             ENQ_ready(current);
             break;
         }
@@ -1578,7 +1585,7 @@ void wt_work_cb(uv_check_t *ev) {
             if (c) {                            // Normal exception handling
                 m->$cont = c->$cont;
                 m->B_value = r.value;
-                rtsd_printf("## FAIL/handle actor %ld : %s", current->$globkey, current->$class->$GCINFO);
+                rtsd_printf("## FAIL/handle actor %ld : %s", current->$globkey, current->$class->$name);
                 ENQ_ready(current);
             } else {                            // An unhandled exception
                 save_actor_state(current, m);
@@ -1590,10 +1597,10 @@ void wt_work_cb(uv_check_t *ev) {
                     b->$waitsfor = NULL;
                     $Actor c = b->$next;
                     ENQ_ready(b);
-                    rtsd_printf("## Propagating exception to actor %ld : %s", b->$globkey, b->$class->$GCINFO);
+                    rtsd_printf("## Propagating exception to actor %ld : %s", b->$globkey, b->$class->$name);
                     b = c;
                 }
-                rtsd_printf("## FAIL actor %ld : %s", current->$globkey, current->$class->$GCINFO);
+                rtsd_printf("## FAIL actor %ld : %s", current->$globkey, current->$class->$name);
                 if (DEQ_msg(current)) {
                     ENQ_ready(current);
                 }
@@ -1626,15 +1633,15 @@ void wt_work_cb(uv_check_t *ev) {
             m->$cont = r.cont;
             B_Msg x = (B_Msg)r.value;
             if (ADD_waiting(current, x)) {      // x->cont is a proper $Cont: x is still being processed so current was added to x->waiting
-                rtsd_printf("## AWAIT actor %ld : %s", current->$globkey, current->$class->$GCINFO);
+                rtsd_printf("## AWAIT actor %ld : %s", current->$globkey, current->$class->$name);
                 current->$waitsfor = x;
             } else if (EXCEPTIONAL(x)) {        // x->cont == MARK_EXCEPTION: x->value holds the raised exception, current is not in x->waiting
-                rtsd_printf("## AWAIT/fail actor %ld : %s", current->$globkey, current->$class->$GCINFO);
+                rtsd_printf("## AWAIT/fail actor %ld : %s", current->$globkey, current->$class->$name);
                 m->$cont = &$Fail$instance;
                 m->B_value = x->B_value;
                 ENQ_ready(current);
             } else {                            // x->cont == MARK_RESULT: x->value holds the final response, current is not in x->waiting
-                rtsd_printf("## AWAIT/wakeup actor %ld : %s", current->$globkey, current->$class->$GCINFO);
+                rtsd_printf("## AWAIT/wakeup actor %ld : %s", current->$globkey, current->$class->$name);
                 m->B_value = x->B_value;
                 ENQ_ready(current);
             }
diff --git a/rts/rts.h b/rts/rts.h
index dade10c4e..6f4c2d8c6 100644
--- a/rts/rts.h
+++ b/rts/rts.h
@@ -51,7 +51,8 @@ extern struct $ConstContG_class $ConstContG_methods;
 #define $Lock                   volatile atomic_flag
 
 struct B_MsgG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)(B_Msg, $Actor, $Cont, time_t, $WORD);
@@ -72,9 +73,11 @@ struct B_Msg {
     $WORD B_value;
     $long $globkey;
 };
+extern GC_word B_MsgD_gcbm[GC_BITMAP_SIZE(struct B_Msg)];
 
 struct $ActorG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($Actor);
@@ -97,9 +100,11 @@ struct $Actor {
     $long $globkey;
     $int64 $affinity;
 };
+extern GC_word $ActorD_gcbm[GC_BITMAP_SIZE(struct $Actor)];
 
 struct $CatcherG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($Catcher, $Cont);
@@ -114,10 +119,12 @@ struct $Catcher {
     $Catcher $next;
     $Cont $cont;
 };
+extern GC_word $CatcherD_gcbm[GC_BITMAP_SIZE(struct $Catcher)];
 
 
 struct $ConstContG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     void (*__init__)($ConstCont, $WORD, $Cont);
@@ -133,6 +140,7 @@ struct $ConstCont {
     $WORD val;
     $Cont cont;
 };
+extern GC_word $ConstContD_gcbm[GC_BITMAP_SIZE(struct $ConstCont)];
 $Cont $CONSTCONT($WORD, $Cont);
 
 B_Msg $ASYNC($Actor, $Cont);
diff --git a/stdlib/c_src/numpy/ndarray.c b/stdlib/c_src/numpy/ndarray.c
index df0961cb7..8d169b0ff 100644
--- a/stdlib/c_src/numpy/ndarray.c
+++ b/stdlib/c_src/numpy/ndarray.c
@@ -363,6 +363,7 @@ numpyQ_ndarray numpyQ_ndarrayD___ndgetslice__(numpyQ_ndarray a, B_list ix) {
 }
 
 struct numpyQ_ndarrayG_class numpyQ_ndarrayG_methods = {
+    0,
     "numpyQ_ndarray",
     UNASSIGNED,
     ($SuperG_class)&B_valueG_methods,
@@ -849,8 +850,7 @@ numpyQ_IteratorD_ndarray numpyQ_IteratorD_ndarray$_deserialize(numpyQ_IteratorD_
     return NULL;
 }
 
-struct numpyQ_IteratorD_ndarrayG_class numpyQ_IteratorD_ndarrayG_methods = {"",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, numpyQ_IteratorD_init,
-                                                                        numpyQ_IteratorD_$serialize, numpyQ_IteratorD_ndarray$_deserialize,numpyQ_IteratorB_bool,
+struct numpyQ_IteratorD_ndarrayG_class numpyQ_IteratorD_ndarrayG_methods = {0,"",UNASSIGNED,($SuperG_class)&B_IteratorG_methods, numpyQ_IteratorD_init,                                                                        numpyQ_IteratorD_$serialize, numpyQ_IteratorD_ndarray$_deserialize,numpyQ_IteratorB_bool,
                                                                         numpyQ_IteratorB_str,numpyQ_IteratorB_str,numpyQ_IteratorD_ndarrayD___next__};
 
 numpyQ_ndarray numpyQ_roll(numpyQ_Primitive pwit, numpyQ_ndarray a, B_int n) {
diff --git a/stdlib/c_src/numpy/ndselect.c b/stdlib/c_src/numpy/ndselect.c
index 206921ac3..fd3ee43e2 100644
--- a/stdlib/c_src/numpy/ndselect.c
+++ b/stdlib/c_src/numpy/ndselect.c
@@ -25,6 +25,7 @@ numpyQ_ndselect numpyQ_ndselectD___deserialize__(numpyQ_ndselect wit, $Serial$st
 }
 
 struct numpyQ_ndselectG_class numpyQ_ndselectG_methods = {
+    0,
     "numpyQ_ndselect",
     UNASSIGNED,
     ($SuperG_class)&B_valueG_methods,
@@ -63,6 +64,7 @@ numpyQ_ndindex numpyQ_ndindexD___deserialize__(numpyQ_ndindex self, $Serial$stat
 }
 
 struct numpyQ_ndindexG_class numpyQ_ndindexG_methods = {
+    0,
     "numpyQ_ndindex",
     UNASSIGNED,
     ($SuperG_class)&B_valueG_methods,
@@ -100,6 +102,7 @@ numpyQ_ndslice numpyQ_ndsliceD___deserialize__(numpyQ_ndslice self, $Serial$stat
 }
 
 struct numpyQ_ndsliceG_class numpyQ_ndsliceG_methods = {
+    0,
     "numpyQ_ndslice",
     UNASSIGNED,
     ($SuperG_class)&B_valueG_methods,
diff --git a/stdlib/c_src/numpy/primitive.c b/stdlib/c_src/numpy/primitive.c
index cdb0f7299..f3659a49b 100644
--- a/stdlib/c_src/numpy/primitive.c
+++ b/stdlib/c_src/numpy/primitive.c
@@ -180,16 +180,14 @@ numpyQ_PrimitiveD_float numpyQ_PrimitiveD_floatD_deserialize(numpyQ_PrimitiveD_f
 }
 
 
-struct numpyQ_PrimitiveD_intG_class numpyQ_PrimitiveD_intG_methods = {"numpyQ_PrimitiveD_int",UNASSIGNED,NULL,(B_NoneType (*)(numpyQ_PrimitiveD_int))$default__init__,
-                                                                  numpyQ_PrimitiveD_intD_serialize,numpyQ_PrimitiveD_intD_deserialize,NULL,NULL,NULL,
+struct numpyQ_PrimitiveD_intG_class numpyQ_PrimitiveD_intG_methods = {0,"numpyQ_PrimitiveD_int",UNASSIGNED,NULL,(B_NoneType (*)(numpyQ_PrimitiveD_int))$default__init__,                                                                  numpyQ_PrimitiveD_intD_serialize,numpyQ_PrimitiveD_intD_deserialize,NULL,NULL,NULL,
                                                                   LongType,to$objB_int,from$objB_int,B_l_prim_str,
                                                                   B_l_add,B_l_sub,B_l_mul,B_l_truediv,B_l_floordiv,B_l_mod,B_l_land,B_l_lor,B_l_band,B_l_bor,B_l_bxor,B_l_lsh,B_l_rsh,lB_pow,
                                                                   B_l_iadd,B_l_isub,B_l_imul,B_l_itruediv,B_l_ifloordiv,B_l_imod,B_l_iband,B_l_ibor,B_l_ibxor,B_l_ilsh,B_l_irsh,
                                                                   B_l_eq,B_l_neq,B_l_lt,B_l_le,B_l_gt,B_l_ge,lB_abs,B_l_neg,B_l_lnot,B_l_bnot};
 
 
-struct numpyQ_PrimitiveD_floatG_class numpyQ_PrimitiveD_floatG_methods = {"numpyQ_PrimitiveD_float",UNASSIGNED,NULL,(B_NoneType (*)(numpyQ_PrimitiveD_float))$default__init__, 
-                                                                      numpyQ_PrimitiveD_floatD_serialize,numpyQ_PrimitiveD_floatD_deserialize,NULL,NULL,NULL,
+struct numpyQ_PrimitiveD_floatG_class numpyQ_PrimitiveD_floatG_methods = {0,"numpyQ_PrimitiveD_float",UNASSIGNED,NULL,(B_NoneType (*)(numpyQ_PrimitiveD_float))$default__init__,                                                                       numpyQ_PrimitiveD_floatD_serialize,numpyQ_PrimitiveD_floatD_deserialize,NULL,NULL,NULL,
                                                                       DblType,to$objB_float,from$objB_float,B_d_prim_str,
                                                                       B_d_add,B_d_sub,B_d_mul,B_d_truediv,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,dB_pow,
                                                                       B_d_iadd,B_d_isub,B_d_imul,B_d_itruediv,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
diff --git a/stdlib/c_src/numpy/protocol_impls.c b/stdlib/c_src/numpy/protocol_impls.c
index 44e9a98af..bcc87ae8b 100644
--- a/stdlib/c_src/numpy/protocol_impls.c
+++ b/stdlib/c_src/numpy/protocol_impls.c
@@ -428,6 +428,7 @@ struct numpyQ_MinusD_ndarray numpyQ_MinusD_ndarray$instance;
 struct numpyQ_SliceableD_ndarray numpyQ_SliceableD_ndarray$instance;
 
 struct numpyQ_IntegralD_ndarrayD_intG_class numpyQ_IntegralD_ndarrayD_intG_methods = {
+    0,
     "numpyQ_IntegralD_ndarrayD_int",
     UNASSIGNED,
     ($SuperG_class)&B_IntegralG_methods,
@@ -477,6 +478,7 @@ struct numpyQ_IntegralD_ndarrayD_int numpyQ_IntegralD_ndarrayD_int$instance = {&
 numpyQ_IntegralD_ndarrayD_int numpyQ_IntegralD_ndarrayD_intG_witness = &numpyQ_IntegralD_ndarrayD_int$instance;
 
 struct numpyQ_LogicalD_ndarrayD_intG_class numpyQ_LogicalD_ndarrayD_intG_methods = {
+    0,
     "numpyQ_LogicalD_ndarrayD_int",
     UNASSIGNED,
     ($SuperG_class)&B_LogicalG_methods,
@@ -498,6 +500,7 @@ struct numpyQ_LogicalD_ndarrayD_int numpyQ_LogicalD_ndarrayD_int$instance = {&nu
 numpyQ_LogicalD_ndarrayD_int numpyQ_LogicalD_ndarrayD_intG_witness = &numpyQ_LogicalD_ndarrayD_int$instance;
 
 struct numpyQ_MinusD_ndarrayD_intG_class numpyQ_MinusD_ndarrayD_intG_methods = {
+    0,
     "numpyQ_MinusD_ndarrayD_int",
     UNASSIGNED,
     ($SuperG_class)&B_MinusG_methods,
@@ -514,6 +517,7 @@ struct numpyQ_MinusD_ndarrayD_int numpyQ_MinusD_ndarrayD_int$instance = {&numpyQ
 numpyQ_MinusD_ndarrayD_int numpyQ_MinusD_ndarrayD_intG_witness = &numpyQ_MinusD_ndarrayD_int$instance;
 
 struct numpyQ_RealD_ndarrayG_class numpyQ_RealD_ndarrayG_methods = {
+    0,
     "numpyQ_RealD_ndarray",
     UNASSIGNED,
     ($SuperG_class)&B_IntegralG_methods,
@@ -545,6 +549,7 @@ struct numpyQ_RealD_ndarrayG_class numpyQ_RealD_ndarrayG_methods = {
 };
  
 struct numpyQ_MinusD_ndarrayG_class numpyQ_MinusD_ndarrayG_methods = {
+    0,
     "numpyQ_MinusD_ndarray",
     UNASSIGNED,
     ($SuperG_class)&B_MinusG_methods,
@@ -562,6 +567,7 @@ struct numpyQ_MinusD_ndarray numpyQ_MinusD_ndarray$instance = {&numpyQ_MinusD_nd
 numpyQ_MinusD_ndarray numpyQ_MinusD_ndarrayG_witness = &numpyQ_MinusD_ndarray$instance;
 
 struct numpyQ_DivD_ndarrayD_intG_class numpyQ_DivD_ndarrayD_intG_methods = {
+    0,
     "numpyQ_DivD_ndarrayD_int",
     UNASSIGNED,
     ($SuperG_class)&B_MinusG_methods,
@@ -579,6 +585,7 @@ struct numpyQ_DivD_ndarrayD_int numpyQ_DivD_ndarrayD_int$instance = {&numpyQ_Div
 numpyQ_DivD_ndarrayD_int numpyQ_DivD_ndarrayD_intG_witness = &numpyQ_DivD_ndarrayD_int$instance;
 
 struct numpyQ_DivD_ndarrayD_floatG_class numpyQ_DivD_ndarrayD_floatG_methods = {
+    0,
     "numpyQ_DivD_ndarrayD_float",
     UNASSIGNED,
     ($SuperG_class)&B_MinusG_methods,
@@ -596,6 +603,7 @@ struct numpyQ_DivD_ndarrayD_float numpyQ_DivD_ndarrayD_float$instance = {&numpyQ
 numpyQ_DivD_ndarrayD_float numpyQ_DivD_ndarrayD_floatG_witness = &numpyQ_DivD_ndarrayD_float$instance;
 
 struct numpyQ_SliceableD_ndarrayG_class numpyQ_SliceableD_ndarrayG_methods = {
+    0,
     "numpyQ_SliceableD_ndarray",
     UNASSIGNED,
     ($SuperG_class)&B_SliceableG_methods,
@@ -617,6 +625,7 @@ numpyQ_SliceableD_ndarray numpyQ_SliceableD_ndarrayG_witness = &numpyQ_Sliceable
 
 
 struct numpyQ_CollectionD_ndarrayG_class numpyQ_CollectionD_ndarrayG_methods = {
+    0,
     "numpyQ_CollectionD_ndarray",
     UNASSIGNED,
     ($SuperG_class)&B_CollectionG_methods,
@@ -728,6 +737,7 @@ numpyQ_RealFunsD_mathD_ndarray numpyQ_RealFunsD_mathD_ndarrayG_new(numpyQ_Primit
     return $tmp;
 }
 struct numpyQ_RealFunsD_mathD_ndarrayG_class numpyQ_RealFunsD_mathD_ndarrayG_methods = {
+    0,
     "numpyQ_RealFunsD_mathD_ndarray",
     UNASSIGNED,
     ($SuperG_class)&mathQ_RealFunsG_methods,
diff --git a/stdlib/src/json.ext.c b/stdlib/src/json.ext.c
index 08f6da217..c317741cb 100644
--- a/stdlib/src/json.ext.c
+++ b/stdlib/src/json.ext.c
@@ -17,7 +17,7 @@ void jsonQ_encode_dict(yyjson_mut_doc *doc, yyjson_mut_val *node, B_dict data) {
         char *key = (char *)fromB_str((B_str)item->components[0]);
         char *value = (char *)fromB_str((B_str)item->components[1]);
         B_value v = item->components[1];
-        //log_info("key: %s  class_id: %d  type: %s", key, v->$class->$class_id, v->$class->$GCINFO);
+        //log_info("key: %s  class_id: %d  type: %s", key, v->$class->$class_id, v->$class->$name);
         switch (v->$class->$class_id) {
             case INT_ID:;
                 yyjson_mut_obj_add_int(doc, node, key, from$int((B_int)v));
diff --git a/stdlib/src/math.c b/stdlib/src/math.c
index 0778aacea..4136c9cf0 100644
--- a/stdlib/src/math.c
+++ b/stdlib/src/math.c
@@ -19,12 +19,13 @@ B_NoneType mathQ_RealFunsD___init__ (mathQ_RealFuns W_self) {
     return B_None;
 }
 mathQ_RealFuns mathQ_RealFunsG_new() {
-    mathQ_RealFuns $tmp = malloc(sizeof(struct mathQ_RealFuns));
+    mathQ_RealFuns $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct mathQ_RealFuns), mathQ_RealFunsG_methods.$GCdescr);
     $tmp->$class = &mathQ_RealFunsG_methods;
     mathQ_RealFunsG_methods.__init__($tmp);
     return $tmp;
 }
 struct mathQ_RealFunsG_class mathQ_RealFunsG_methods;
+GC_word mathQ_RealFunsD_gcbm[GC_BITMAP_SIZE(struct mathQ_RealFuns)];
 B_NoneType mathQ_RealFunsD_floatD___init__ (mathQ_RealFunsD_float W_self) {
     mathQ_RealFunsG_methods.__init__((mathQ_RealFuns)W_self);
     return B_None;
@@ -86,24 +87,29 @@ B_float mathQ_RealFunsD_float$atanh(mathQ_RealFunsD_float wit, B_float x) {
 
                       
 mathQ_RealFunsD_float mathQ_RealFunsD_floatG_new() {
-    mathQ_RealFunsD_float $tmp = malloc(sizeof(struct mathQ_RealFunsD_float));
+    mathQ_RealFunsD_float $tmp = GC_MALLOC_EXPLICITLY_TYPED(sizeof(struct mathQ_RealFunsD_float), mathQ_RealFunsD_floatG_methods.$GCdescr);
     $tmp->$class = &mathQ_RealFunsD_floatG_methods;
     mathQ_RealFunsD_floatG_methods.__init__($tmp);
     return $tmp;
 }
 struct mathQ_RealFunsD_floatG_class mathQ_RealFunsD_floatG_methods;
+GC_word mathQ_RealFunsD_floatD_gcbm[GC_BITMAP_SIZE(struct mathQ_RealFunsD_float)];
 int mathQ_done$ = 0;
 void mathQ___init__ () {
     if (mathQ_done$) return;
     mathQ_done$ = 1;
     {
-        mathQ_RealFunsG_methods.$GCINFO = "mathQ_RealFuns";
+        memset(mathQ_RealFunsD_gcbm, 0xFF, sizeof(mathQ_RealFunsD_gcbm));
+        mathQ_RealFunsG_methods.$GCdescr = GC_make_descriptor(mathQ_RealFunsD_gcbm, GC_WORD_LEN(struct mathQ_RealFuns));
+        mathQ_RealFunsG_methods.$name = "mathQ_RealFuns";
         mathQ_RealFunsG_methods.$superclass = NULL;
         mathQ_RealFunsG_methods.__init__ = mathQ_RealFunsD___init__;
         $register(&mathQ_RealFunsG_methods);
     }
     {
-        mathQ_RealFunsD_floatG_methods.$GCINFO = "mathQ_RealFunsD_float";
+        memset(mathQ_RealFunsD_floatD_gcbm, 0xFF, sizeof(mathQ_RealFunsD_floatD_gcbm));
+        mathQ_RealFunsD_floatG_methods.$GCdescr = GC_make_descriptor(mathQ_RealFunsD_floatD_gcbm, GC_WORD_LEN(struct mathQ_RealFunsD_float));
+        mathQ_RealFunsD_floatG_methods.$name = "mathQ_RealFunsD_float";
         mathQ_RealFunsD_floatG_methods.$superclass = ($SuperG_class)&mathQ_RealFunsG_methods;
         mathQ_RealFunsD_floatG_methods.__serialize__ = mathQ_RealFunsD_floatD___serialize__,
         mathQ_RealFunsD_floatG_methods.__deserialize__ = mathQ_RealFunsD_floatD___deserialize__,
diff --git a/stdlib/src/math.h b/stdlib/src/math.h
index 3dd41be1a..03671958c 100644
--- a/stdlib/src/math.h
+++ b/stdlib/src/math.h
@@ -5,7 +5,8 @@
 struct mathQ_RealFuns;
 typedef struct mathQ_RealFuns *mathQ_RealFuns;
 struct mathQ_RealFunsG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     B_int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (mathQ_RealFuns);
@@ -33,12 +34,14 @@ struct mathQ_RealFunsG_class {
 struct mathQ_RealFuns {
     struct mathQ_RealFunsG_class *$class;
 };
+extern GC_word mathQ_RealFunsD_gcbm[GC_BITMAP_SIZE(struct mathQ_RealFuns)];
 extern struct mathQ_RealFunsG_class mathQ_RealFunsG_methods;
 mathQ_RealFuns mathQ_RealFunsG_new();
 struct mathQ_RealFunsD_float;
 typedef struct mathQ_RealFunsD_float *mathQ_RealFunsD_float;
 struct mathQ_RealFunsD_floatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     B_int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (mathQ_RealFunsD_float);
@@ -66,6 +69,7 @@ struct mathQ_RealFunsD_floatG_class {
 struct mathQ_RealFunsD_float {
     struct mathQ_RealFunsD_floatG_class *$class;
 };
+extern GC_word mathQ_RealFunsD_floatD_gcbm[GC_BITMAP_SIZE(struct mathQ_RealFunsD_float)];
 extern struct mathQ_RealFunsD_floatG_class mathQ_RealFunsD_floatG_methods;
 mathQ_RealFunsD_float mathQ_RealFunsD_floatG_new();
 $WORD mathQ_sqrt (mathQ_RealFuns, $WORD);
diff --git a/stdlib/src/numpy.h b/stdlib/src/numpy.h
index 0fdc7633c..f93a7b8ca 100644
--- a/stdlib/src/numpy.h
+++ b/stdlib/src/numpy.h
@@ -6,7 +6,8 @@
 struct numpyQ_ndselect;
 typedef struct numpyQ_ndselect *numpyQ_ndselect;
 struct numpyQ_ndselectG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (numpyQ_ndselect);
@@ -19,12 +20,14 @@ struct numpyQ_ndselectG_class {
 struct numpyQ_ndselect {
     struct numpyQ_ndselectG_class *$class;
 };
+extern GC_word numpyQ_ndselectD_gcbm[GC_BITMAP_SIZE(struct numpyQ_ndselect)];
 extern struct numpyQ_ndselectG_class numpyQ_ndselectG_methods;
 numpyQ_ndselect numpyQ_ndselectG_new();
 struct numpyQ_ndindex;
 typedef struct numpyQ_ndindex *numpyQ_ndindex;
 struct numpyQ_ndindexG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (numpyQ_ndindex, B_int);
@@ -38,6 +41,7 @@ struct numpyQ_ndindex {
     struct numpyQ_ndindexG_class *$class;
     B_int index;
 };
+extern GC_word numpyQ_ndindexD_gcbm[GC_BITMAP_SIZE(struct numpyQ_ndindex)];
 extern struct numpyQ_ndindexG_class numpyQ_ndindexG_methods;
 numpyQ_ndindex numpyQ_ndindexG_new(B_int);
 
@@ -45,7 +49,8 @@ numpyQ_ndindex numpyQ_ndindexG_new(B_int);
 struct numpyQ_ndslice;
 typedef struct numpyQ_ndslice *numpyQ_ndslice;
 struct numpyQ_ndsliceG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (numpyQ_ndslice, B_slice);
@@ -59,6 +64,7 @@ struct numpyQ_ndslice {
     struct numpyQ_ndsliceG_class *$class;
     B_slice slc;
 };
+extern GC_word numpyQ_ndsliceD_gcbm[GC_BITMAP_SIZE(struct numpyQ_ndslice)];
 extern struct numpyQ_ndsliceG_class numpyQ_ndsliceG_methods;
 numpyQ_ndslice numpyQ_ndsliceG_new(B_slice);
 
@@ -92,6 +98,7 @@ typedef struct numpyQ_PrimitiveD_floatG_class *numpyQ_PrimitiveD_floatG_class;
 struct numpyQ_Primitive {
     numpyQ_PrimitiveG_class $class;
 };
+extern GC_word numpyQ_PrimitiveD_gcbm[GC_BITMAP_SIZE(struct numpyQ_Primitive)];
 
 union $Bytes8 {
   long l;
@@ -103,7 +110,8 @@ enum ElemType {LongType,DblType};
 int $elem_size(enum ElemType typ);
 
 struct numpyQ_PrimitiveG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   B_NoneType (*__init__)(numpyQ_Primitive);
@@ -161,9 +169,11 @@ B_str B_l_prim_str(union $Bytes8 n);
 struct numpyQ_PrimitiveD_int {
     numpyQ_PrimitiveD_intG_class $class;
 };
+extern GC_word numpyQ_PrimitiveD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_PrimitiveD_int)];
 
 struct numpyQ_PrimitiveD_intG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   B_NoneType (*__init__)(numpyQ_PrimitiveD_int);
@@ -218,9 +228,11 @@ struct numpyQ_PrimitiveD_intG_class {
 struct numpyQ_PrimitiveD_float {
   numpyQ_PrimitiveD_floatG_class $class;
 };
+extern GC_word numpyQ_PrimitiveD_floatD_gcbm[GC_BITMAP_SIZE(struct numpyQ_PrimitiveD_float)];
 
 struct numpyQ_PrimitiveD_floatG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   B_NoneType (*__init__)(numpyQ_PrimitiveD_float);
@@ -287,7 +299,8 @@ struct numpyQ_ndarray;
 typedef struct numpyQ_ndarray *numpyQ_ndarray;
 
 struct numpyQ_ndarrayG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   B_NoneType (*__init__)(numpyQ_ndarray,numpyQ_Primitive,B_atom);
@@ -314,6 +327,7 @@ struct numpyQ_ndarray {
   B_list strides;
   union $Bytes8 *data;
 };
+extern GC_word numpyQ_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_ndarray)];
 
 extern struct numpyQ_ndarrayG_class numpyQ_ndarrayG_methods;
 
@@ -338,7 +352,8 @@ typedef struct numpyQ_array_iterator_state {
 typedef struct numpyQ_IteratorD_ndarray *numpyQ_IteratorD_ndarray; ;
 
 struct numpyQ_IteratorD_ndarrayG_class {
-  char *$GCINFO;
+  GC_descr $GCdescr;
+  char *$name;
   int $class_id;
   $SuperG_class $superclass;
   B_NoneType (*__init__)(numpyQ_IteratorD_ndarray, numpyQ_Primitive, numpyQ_ndarray);
@@ -357,6 +372,7 @@ struct numpyQ_IteratorD_ndarray {
   numpyQ_Primitive pwit;
   numpyQ_array_iterator_state it;
 };
+extern GC_word numpyQ_IteratorD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_IteratorD_ndarray)];
 
 extern struct  numpyQ_IteratorD_ndarrayG_class  numpyQ_IteratorD_ndarrayG_methods;
 
@@ -466,9 +482,11 @@ struct numpyQ_IntegralD_ndarrayD_int {
     B_Logical W_Logical;
     B_Minus W_Minus;
 };
+extern GC_word numpyQ_IntegralD_ndarrayD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_IntegralD_ndarrayD_int)];
 
 struct numpyQ_IntegralD_ndarrayD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(numpyQ_IntegralD_ndarrayD_int);
@@ -549,9 +567,11 @@ struct numpyQ_LogicalD_ndarrayD_int {
     numpyQ_LogicalD_ndarrayD_intG_class $class;
     B_Integral W_Integral;
 };
+extern GC_word numpyQ_LogicalD_ndarrayD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_LogicalD_ndarrayD_int)];
 
 struct numpyQ_LogicalD_ndarrayD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(numpyQ_LogicalD_ndarrayD_int, B_Integral);
@@ -581,9 +601,11 @@ struct numpyQ_MinusD_ndarrayD_int {
     numpyQ_MinusD_ndarrayD_intG_class $class;
     B_Integral W_Integral;
 };
+extern GC_word numpyQ_MinusD_ndarrayD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_MinusD_ndarrayD_int)];
 
 struct numpyQ_MinusD_ndarrayD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(numpyQ_MinusD_ndarrayD_int, B_Integral);
@@ -608,9 +630,11 @@ struct numpyQ_RealD_ndarray {
     B_Minus W_Minus;
     numpyQ_Primitive W_PrimitiveD_AD_RealD_ndarray;
 };
+extern GC_word numpyQ_RealD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_RealD_ndarray)];
 
 struct numpyQ_RealD_ndarrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
   B_NoneType (*__init__)(numpyQ_RealD_ndarray, numpyQ_Primitive);
@@ -667,9 +691,11 @@ struct numpyQ_MinusD_ndarray {
     numpyQ_MinusD_ndarrayG_class $class;
     B_Real W_Real;
 };
+extern GC_word numpyQ_MinusD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_MinusD_ndarray)];
 
 struct numpyQ_MinusD_ndarrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(numpyQ_MinusD_ndarray, B_Real);
@@ -693,9 +719,11 @@ struct numpyQ_DivD_ndarrayD_int {
     numpyQ_DivD_ndarrayD_intG_class $class;
     B_Real W_Real;
 };
+extern GC_word numpyQ_DivD_ndarrayD_intD_gcbm[GC_BITMAP_SIZE(struct numpyQ_DivD_ndarrayD_int)];
 
 struct numpyQ_DivD_ndarrayD_intG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(numpyQ_DivD_ndarrayD_int);
@@ -719,9 +747,11 @@ struct numpyQ_DivD_ndarrayD_float {
     numpyQ_DivD_ndarrayD_floatG_class $class;
     B_Real W_Real;
 };
+extern GC_word numpyQ_DivD_ndarrayD_floatD_gcbm[GC_BITMAP_SIZE(struct numpyQ_DivD_ndarrayD_float)];
 
 struct numpyQ_DivD_ndarrayD_floatG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(numpyQ_DivD_ndarrayD_float);
@@ -745,7 +775,8 @@ struct numpyQ_SliceableD_ndarray;
 typedef struct numpyQ_SliceableD_ndarray *numpyQ_SliceableD_ndarray;
 
 struct numpyQ_SliceableD_ndarrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (numpyQ_SliceableD_ndarray, numpyQ_Primitive);
@@ -765,6 +796,7 @@ struct numpyQ_SliceableD_ndarray {
     numpyQ_SliceableD_ndarrayG_class $class;
     numpyQ_Primitive pwit;
 };
+extern GC_word numpyQ_SliceableD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_SliceableD_ndarray)];
 
 
 // numpyQ_CollectionD_ndarray ////////////////////////////////////////////////////////////
@@ -773,9 +805,11 @@ struct numpyQ_CollectionD_ndarray {
   numpyQ_CollectionD_ndarrayG_class $class;
   numpyQ_Primitive pwit;
 };
+extern GC_word numpyQ_CollectionD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_CollectionD_ndarray)];
 
 struct numpyQ_CollectionD_ndarrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__)(numpyQ_CollectionD_ndarray, numpyQ_Primitive);
@@ -806,7 +840,8 @@ numpyQ_RealD_ndarray numpyQ_RealFloat$ndarrayG_new(numpyQ_Primitive,B_RealFloat)
 struct numpyQ_RealFunsD_mathD_ndarray;
 typedef struct numpyQ_RealFunsD_mathD_ndarray *numpyQ_RealFunsD_mathD_ndarray;
 struct numpyQ_RealFunsD_mathD_ndarrayG_class {
-    char *$GCINFO;
+    GC_descr $GCdescr;
+    char *$name;
     int $class_id;
     $SuperG_class $superclass;
     B_NoneType (*__init__) (numpyQ_RealFunsD_mathD_ndarray, numpyQ_Primitive, mathQ_RealFuns);
@@ -836,6 +871,7 @@ struct numpyQ_RealFunsD_mathD_ndarray {
     numpyQ_Primitive W_PrimitiveD_AD_RealFuns$math$ndarray;
   mathQ_RealFuns W_RealFuns$mathD_AD_RealFuns$math$ndarray;
 };
+extern GC_word numpyQ_RealFunsD_mathD_ndarrayD_gcbm[GC_BITMAP_SIZE(struct numpyQ_RealFunsD_mathD_ndarray)];
 extern struct numpyQ_RealFunsD_mathD_ndarrayG_class numpyQ_RealFunsD_mathD_ndarrayG_methods;