diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 9ba109d2..81cbc1ca 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -55,12 +55,15 @@ use std::rc::Rc;
 )");
 }
 
-std::string Converter::EmitOpaqueRecords() {
+std::string Converter::EmitOpaqueRecords(bool emit_byte_repr) {
   std::string out;
   record_decls_.ForEachUndefined([&](const std::string &name) {
     out += "pub struct ";
     out += name;
     out += ";\n";
+    if (emit_byte_repr) {
+      out += "impl ByteRepr for " + name + " {}\n";
+    }
   });
   return out;
 }
@@ -753,6 +756,11 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
     }
   }
 
+  if (decl->isUnion()) {
+    EmitRustUnion(decl);
+    return;
+  }
+
   // Derived traits
   if (EmitsReprCForRecords()) {
     StrCat("#[repr(C)]");
@@ -770,8 +778,7 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
   auto access = clang::dyn_cast<clang::CXXRecordDecl>(decl)
                     ? AccessSpecifierAsString(decl->getAccess())
                     : keyword::kPub;
-  StrCat(access, decl->isUnion() ? keyword::kUnion : keyword::kStruct,
-         GetRecordName(decl));
+  StrCat(access, keyword::kStruct, GetRecordName(decl));
   {
     PushBrace brace(*this);
     for (auto *field : decl->fields()) {
@@ -817,6 +824,31 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
   AddByteReprTrait(decl);
 }
 
+void Converter::EmitRustUnion(clang::RecordDecl *decl) {
+  if (EmitsReprCForRecords()) {
+    StrCat("#[repr(C)]");
+  }
+  auto attrs = GetStructAttributes(decl);
+  Mapper::SetDerives(ctx_.getCanonicalTagType(decl),
+                     std::vector<std::string>(attrs.begin(), attrs.end()));
+  StrCat("#[derive(");
+  for (auto *attr : attrs) {
+    StrCat(attr, ',');
+  }
+  StrCat(")]");
+
+  StrCat(keyword::kPub, keyword::kUnion, GetRecordName(decl));
+  {
+    PushBrace brace(*this);
+    for (auto *field : decl->fields()) {
+      VisitFieldDecl(field);
+    }
+  }
+
+  AddDefaultTrait(decl);
+  AddByteReprTrait(decl);
+}
+
 bool Converter::VisitCXXRecordDecl(clang::CXXRecordDecl *decl) {
   if (clang::isa<clang::ClassTemplateSpecializationDecl>(decl)) {
     materializeTemplateSpecialization(decl);
@@ -3136,6 +3168,7 @@ bool Converter::VisitEnumDecl(clang::EnumDecl *decl) {
 
   AddFromImpl(decl);
   AddIncDecImpls(decl);
+  AddByteReprTrait(decl);
   return false;
 }
 
@@ -3918,6 +3951,8 @@ void Converter::EmitDefaultStructLiteral(const clang::RecordDecl *decl) {
 
 void Converter::AddByteReprTrait(const clang::RecordDecl *decl) {}
 
+void Converter::AddByteReprTrait(const clang::EnumDecl *decl) {}
+
 void Converter::ConvertUnsignedArithBinaryOperator(clang::BinaryOperator *op,
                                                    clang::Expr *expr) {
   StrCat(token::kDot);
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 63de20e4..7d0f2571 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -50,7 +50,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitFilePreamble();
 
-  static std::string EmitOpaqueRecords();
+  static std::string EmitOpaqueRecords(bool emit_byte_repr);
 
   virtual bool VisitBuiltinType(clang::BuiltinType *type);
 
@@ -112,6 +112,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitRustStructOrUnion(clang::RecordDecl *decl);
 
+  virtual void EmitRustUnion(clang::RecordDecl *decl);
+
   virtual bool EmitsReprCForRecords() const { return true; }
 
   virtual bool VisitCXXMethodDecl(clang::CXXMethodDecl *decl);
@@ -539,6 +541,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void AddByteReprTrait(const clang::RecordDecl *decl);
 
+  virtual void AddByteReprTrait(const clang::EnumDecl *decl);
+
   virtual void
   ConvertUnsignedArithBinaryOperator(clang::BinaryOperator *binary_operator,
                                      clang::Expr *expr);
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index 12c0bf69..60fa9c65 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -199,6 +199,42 @@ bool IsMut(clang::QualType qual_type) {
            qual_type->getPointeeType().isConstQualified());
 }
 
+bool TypeImplementsByteRepr(clang::QualType qt) {
+  if (qt->isIntegerType() || qt->isFloatingType()) {
+    return true;
+  }
+  if (qt->isPointerType()) {
+    return true;
+  }
+  if (const auto *arr = qt->getAsArrayTypeUnsafe()) {
+    return TypeImplementsByteRepr(arr->getElementType());
+  }
+  if (const auto *rd = qt->getAsRecordDecl()) {
+    if (rd->isUnion()) {
+      return true;
+    }
+    for (const auto *field : rd->fields()) {
+      if (!TypeImplementsByteRepr(field->getType())) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+bool RustSizeDivergesFromC(clang::QualType qt) {
+  qt = qt.getCanonicalType();
+  // Records have Rc<RefCell<>> fields that diverge from the C size
+  if (qt->isRecordType()) {
+    return true;
+  }
+  if (auto *arr = qt->getAsArrayTypeUnsafe()) {
+    return RustSizeDivergesFromC(arr->getElementType());
+  }
+  return false;
+}
+
 bool IsMutatingCall(const clang::CallExpr *expr) {
   if (auto *callee = expr->getDirectCallee()) {
     if (auto *method = clang::dyn_cast<clang::CXXMethodDecl>(callee)) {
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index a09e0e5d..cd7e9d5a 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -51,6 +51,10 @@ bool IsUnsignedArithOp(const clang::BinaryOperator *expr);
 
 bool IsMut(clang::QualType qual_type);
 
+bool TypeImplementsByteRepr(clang::QualType qt);
+
+bool RustSizeDivergesFromC(clang::QualType qt);
+
 bool IsMutatingCall(const clang::CallExpr *expr);
 
 bool IsOverloadedFunction(const clang::FunctionDecl *decl);
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 7fb3bc9a..ff3dec67 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -469,6 +469,46 @@ void ConverterRefCount::AddDefaultTrait(const clang::RecordDecl *decl) {
 }
 
 void ConverterRefCount::AddDefaultTraitForUnion(const clang::RecordDecl *decl) {
+  auto name = GetRecordName(decl);
+  StrCat(std::format("impl Default for {}", name));
+  PushBrace impl_brace(*this);
+  StrCat("fn default() -> Self");
+  PushBrace fn_brace(*this);
+  StrCat(std::format("{} {{ __store: libcc2rs::UnionStorage::new({}) }}", name,
+                     ctx_.getASTRecordLayout(decl).getSize().getQuantity()));
+}
+
+void ConverterRefCount::EmitRustUnion(clang::RecordDecl *decl) {
+  auto name = GetRecordName(decl);
+
+  auto attrs = GetStructAttributes(decl);
+  Mapper::SetDerives(ctx_.getCanonicalTagType(decl),
+                     std::vector<std::string>(attrs.begin(), attrs.end()));
+  StrCat("#[derive(");
+  for (auto *attr : attrs) {
+    StrCat(attr, ',');
+  }
+  StrCat(")]");
+
+  StrCat(std::format("pub struct {} {{ __store: libcc2rs::UnionStorage, }}",
+                     name));
+
+  StrCat(std::format("impl {}", name));
+  {
+    PushBrace impl_brace(*this);
+    for (auto *field : decl->fields()) {
+      PushConversionKind push(*this, ConversionKind::FullRefCount);
+      std::string storage_ty = ToString(field->getType());
+      Unwrap(storage_ty, "Value<", ">");
+      auto byte_size = ctx_.getTypeSize(field->getType()) / 8;
+      StrCat(std::format("pub fn {}(&self) -> Ptr<{}> {{ "
+                         "self.__store.reinterpret_sized(0, {}) }}",
+                         GetNamedDeclAsString(field), storage_ty, byte_size));
+    }
+  }
+
+  AddDefaultTrait(decl);
+  AddByteReprTrait(decl);
 }
 
 void ConverterRefCount::AddDropTrait(const clang::CXXRecordDecl *decl) {
@@ -501,30 +541,23 @@ void ConverterRefCount::AddDropTrait(const clang::CXXRecordDecl *decl) {
   StrCat('}');
 }
 
-static bool recordImplementsByteRepr(const clang::RecordDecl *decl) {
-  if (decl->isUnion()) {
-    return false;
-  }
-
-  // ByteRepr is only supported for user-defined structs that contain ByteRepr
-  // fields.
-  for (auto *f : decl->fields()) {
-    auto qt = f->getType();
-    if (qt->isEnumeralType()) {
-      return false;
-    }
-    if (!qt->isIntegerType() && !qt->isFloatingType()) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 void ConverterRefCount::AddByteReprTrait(const clang::RecordDecl *decl) {
   auto struct_name = GetRecordName(decl);
 
-  if (!recordImplementsByteRepr(decl)) {
+  if (decl->isUnion()) {
+    StrCat(std::format("impl ByteRepr for {}", struct_name));
+    PushBrace impl_brace(*this);
+    StrCat(std::format("fn byte_size() -> usize {{ {} }}",
+                       ctx_.getTypeSize(ctx_.getCanonicalTagType(decl)) / 8));
+    StrCat(
+        "fn to_bytes(&self, buf: &mut [u8]) { self.__store.to_bytes(buf); }");
+    StrCat(std::format("fn from_bytes(buf: &[u8]) -> Self {{ {} {{ __store: "
+                       "libcc2rs::UnionStorage::from_bytes(buf) }} }}",
+                       struct_name));
+    return;
+  }
+
+  if (!TypeImplementsByteRepr(ctx_.getCanonicalTagType(decl))) {
     StrCat(std::format("impl ByteRepr for {}", struct_name));
     PushBrace brace(*this);
     return;
@@ -535,6 +568,9 @@ void ConverterRefCount::AddByteReprTrait(const clang::RecordDecl *decl) {
 
   const auto &layout = ctx_.getASTRecordLayout(decl);
 
+  StrCat(std::format("fn byte_size() -> usize {{ {} }}",
+                     ctx_.getTypeSize(ctx_.getCanonicalTagType(decl)) / 8));
+
   StrCat("fn to_bytes(&self, buf: &mut [u8])");
   {
     PushBrace fn_brace(*this);
@@ -558,15 +594,31 @@ void ConverterRefCount::AddByteReprTrait(const clang::RecordDecl *decl) {
     for (auto *field : decl->fields()) {
       auto byte_off = layout.getFieldOffset(idx) / 8;
       auto byte_size = ctx_.getTypeSize(field->getType()) / 8;
+      PushConversionKind push(*this, ConversionKind::FullRefCount);
+      std::string storage_ty = ToString(field->getType());
+      Unwrap(storage_ty, "Value<", ">");
       StrCat(std::format(
           "{}: Rc::new(RefCell::new(<{}>::from_bytes(&buf[{}..{}]))),",
-          GetNamedDeclAsString(field), Mapper::Map(field->getType()), byte_off,
+          GetNamedDeclAsString(field), storage_ty, byte_off,
           byte_off + byte_size));
       ++idx;
     }
   }
 }
 
+void ConverterRefCount::AddByteReprTrait(const clang::EnumDecl *decl) {
+  auto name = GetRecordName(decl);
+  StrCat(std::format("impl ByteRepr for {}", name));
+  PushBrace impl_brace(*this);
+  StrCat(std::format("fn byte_size() -> usize {{ {} }}",
+                     ctx_.getTypeSize(ctx_.getCanonicalTagType(decl)) / 8));
+  StrCat(
+      "fn to_bytes(&self, buf: &mut [u8]) { (*self as i32).to_bytes(buf); }");
+  StrCat(std::format("fn from_bytes(buf: &[u8]) -> Self {{ "
+                     "<{}>::from(i32::from_bytes(buf)) }}",
+                     name));
+}
+
 std::string
 ConverterRefCount::GetSelfMaybeWithMut(const clang::CXXMethodDecl *decl) {
   return "&self";
@@ -1246,7 +1298,7 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
                expr->getType()->isPointerType()) {
       Convert(expr->getSubExpr());
       PushConversionKind push(*this, ConversionKind::Unboxed);
-      StrCat(std::format(".cast::<{}>().expect(\"ub:wrong type\")",
+      StrCat(std::format(".reinterpret_cast::<{}>()",
                          ConvertPointeeType(expr->getType())));
       return false;
     } else if (expr->getType()->isVoidPointerType() &&
@@ -1258,9 +1310,17 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
     } else if (expr->getSubExpr()->getType()->isPointerType() &&
                !expr->getSubExpr()->isNullPointerConstant(
                    ctx_, clang::Expr::NPC_ValueDependentIsNull)) {
-      StrCat(std::format("({}.to_strong().as_pointer() as {})",
-                         ToString(expr->getSubExpr()),
-                         ToString(expr->getType())));
+      auto src_pointee = expr->getSubExpr()->getType()->getPointeeType();
+      auto dst_pointee = expr->getType()->getPointeeType();
+      if (ctx_.hasSameUnqualifiedType(src_pointee, dst_pointee)) {
+        StrCat(std::format("({}.to_strong().as_pointer() as {})",
+                           ToString(expr->getSubExpr()),
+                           ToString(expr->getType())));
+      } else {
+        StrCat(std::format("{}.reinterpret_cast::<{}>()",
+                           ToString(expr->getSubExpr()),
+                           ConvertPointeeType(expr->getType())));
+      }
       return false;
     }
     return Converter::VisitExplicitCastExpr(expr);
@@ -1269,6 +1329,20 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
   }
 }
 
+bool ConverterRefCount::VisitUnaryExprOrTypeTraitExpr(
+    clang::UnaryExprOrTypeTraitExpr *expr) {
+  if (expr->getKind() == clang::UnaryExprOrTypeTrait::UETT_SizeOf) {
+    auto arg_type = expr->isArgumentType() ? expr->getArgumentType()
+                                           : expr->getArgumentExpr()->getType();
+    if (RustSizeDivergesFromC(arg_type)) {
+      StrCat(std::format("{}usize", ctx_.getTypeSize(arg_type) / 8));
+      computed_expr_type_ = ComputedExprType::FreshValue;
+      return false;
+    }
+  }
+  return Converter::VisitUnaryExprOrTypeTraitExpr(expr);
+}
+
 bool ConverterRefCount::VisitStmtExpr(clang::StmtExpr *expr) {
   PushConversionKind push(*this, ConversionKind::FullRefCount);
   return Converter::VisitStmtExpr(expr);
@@ -1451,6 +1525,43 @@ bool ConverterRefCount::VisitMemberExpr(clang::MemberExpr *expr) {
     return false;
   }
 
+  if (auto *parent =
+          clang::dyn_cast<clang::RecordDecl>(member->getDeclContext());
+      parent && parent->isUnion() && clang::isa<clang::FieldDecl>(member)) {
+    std::string str;
+    {
+      Buffer buf(*this);
+      PushExprKind push(*this,
+                        isLValue() ? ExprKind::LValue : ExprKind::RValue);
+      Converter::ConvertMemberExpr(expr);
+      str = std::move(buf).str();
+    }
+    str += "()";
+
+    if (isAddrOf()) {
+      if (member->getType()->isArrayType()) {
+        PushConversionKind push(*this, ConversionKind::Unboxed);
+        StrCat(std::format(
+            "{}.reinterpret_cast::<{}>()", str,
+            ToString(
+                member->getType()->getAsArrayTypeUnsafe()->getElementType())));
+      } else {
+        StrCat(str);
+      }
+      computed_expr_type_ = ComputedExprType::FreshPointer;
+      return false;
+    }
+    if (isLValue()) {
+      pending_deref_.set(str);
+      if (member->getType()->isRecordType()) {
+        StrCat("__v");
+      }
+      return false;
+    }
+    StrCat(DerefPtrExpr(str, member->getType()));
+    return false;
+  }
+
   std::string str;
   if (known) {
     str = GetMappedAsString(expr);
@@ -1789,6 +1900,11 @@ std::vector<const char *>
 ConverterRefCount::GetStructAttributes(const clang::RecordDecl *decl) {
   std::vector<const char *> attrs;
 
+  if (decl->isUnion()) {
+    attrs.emplace_back("Clone");
+    return attrs;
+  }
+
   if (RecordDerivesDefault(decl)) {
     attrs.emplace_back("Default");
   }
@@ -1876,7 +1992,11 @@ void ConverterRefCount::EmitSetOrAssign(clang::Expr *lhs,
   auto lhs_str = ConvertLValue(lhs);
   if (!pending_deref_.empty()) {
     auto ptr = pending_deref_.take();
-    StrCat(ptr, ".write(", rhs, ')');
+    if (lhs_str.empty()) {
+      StrCat(ptr, ".write(", rhs, ')');
+    } else {
+      StrCat(ptr, ".with_mut(|__v| ", lhs_str, token::kAssign, rhs, ')');
+    }
   } else {
     StrCat(lhs_str, token::kAssign, rhs);
   }
diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h
index 0d9d9296..cf2a1bcb 100644
--- a/cpp2rust/converter/models/converter_refcount.h
+++ b/cpp2rust/converter/models/converter_refcount.h
@@ -28,6 +28,8 @@ class ConverterRefCount final : public Converter {
 
   bool VisitCXXRecordDecl(clang::CXXRecordDecl *decl) override;
 
+  void EmitRustUnion(clang::RecordDecl *decl) override;
+
   bool EmitsReprCForRecords() const override { return false; }
 
   void ConvertOrdAndPartialOrdTraits(const clang::CXXRecordDecl *decl,
@@ -39,6 +41,11 @@ class ConverterRefCount final : public Converter {
 
   void AddByteReprTrait(const clang::RecordDecl *decl) override;
 
+  void AddByteReprTrait(const clang::EnumDecl *decl) override;
+
+  bool
+  VisitUnaryExprOrTypeTraitExpr(clang::UnaryExprOrTypeTraitExpr *expr) override;
+
   void AddDefaultTrait(const clang::RecordDecl *decl) override;
 
   void AddDefaultTraitForUnion(const clang::RecordDecl *decl) override;
diff --git a/cpp2rust/cpp2rust_lib.cpp b/cpp2rust/cpp2rust_lib.cpp
index 100d6d93..a19a03c3 100644
--- a/cpp2rust/cpp2rust_lib.cpp
+++ b/cpp2rust/cpp2rust_lib.cpp
@@ -30,7 +30,7 @@ std::string TranspileSrc(std::string_view cc_code, Model model,
                                        rules_dir),
       cc_code, tool_args, std::filesystem::path(filename).filename().string(),
       filename.ends_with(".c") ? CLANG_C_COMPILER : CLANG_CXX_COMPILER);
-  rs_code += Converter::EmitOpaqueRecords();
+  rs_code += Converter::EmitOpaqueRecords(model == Model::kRefCount);
   return rs_code;
 }
 
@@ -70,7 +70,7 @@ std::string TranspileDir(std::string_view build_dir, Model model,
   std::string rs_code;
   FrontendActionFactory factory(rs_code, model, rules_dir);
   Tool.run(&factory);
-  rs_code += Converter::EmitOpaqueRecords();
+  rs_code += Converter::EmitOpaqueRecords(model == Model::kRefCount);
   return rs_code;
 }
 } // namespace cpp2rust
diff --git a/libcc2rs/src/fn_ptr.rs b/libcc2rs/src/fn_ptr.rs
index 2ccc150e..81b5e6b5 100644
--- a/libcc2rs/src/fn_ptr.rs
+++ b/libcc2rs/src/fn_ptr.rs
@@ -6,7 +6,7 @@ use std::marker::PhantomData;
 use std::ops::Deref;
 use std::rc::Rc;
 
-use crate::rc::{AnyPtr, ErasedPtr};
+use crate::rc::{AnyPtr, ErasedPtr, Ptr};
 use crate::reinterpret::ByteRepr;
 
 pub trait FnAddr {
@@ -146,24 +146,21 @@ impl<T> Eq for FnPtr<T> {}
 impl<T: 'static> ByteRepr for FnPtr<T> {}
 
 impl<T: 'static> ErasedPtr for FnPtr<T> {
-    fn pointee_type_id(&self) -> TypeId {
-        TypeId::of::<T>()
-    }
-    fn memcpy(&self, _src: &dyn ErasedPtr, _len: usize) {
-        panic!("memcpy not supported on fn pointer");
+    fn as_bytes(&self) -> Ptr<u8> {
+        panic!("byte view not supported on fn pointer");
     }
     fn as_any(&self) -> &dyn Any {
         self
     }
-    fn equals(&self, other: &dyn ErasedPtr) -> Option<bool> {
-        if self.pointee_type_id() != other.pointee_type_id() {
-            return None;
-        }
-        other.as_any().downcast_ref::<FnPtr<T>>().map(|o| self == o)
+    fn equals(&self, other: &dyn ErasedPtr) -> bool {
+        other.as_any().downcast_ref::<FnPtr<T>>() == Some(self)
     }
     fn is_null(&self) -> bool {
         FnPtr::is_null(self)
     }
+    fn address(&self) -> usize {
+        self.original.as_ref().map_or(0, |f| f.addr())
+    }
 }
 
 impl<T: 'static> FnPtr<T> {
diff --git a/libcc2rs/src/lib.rs b/libcc2rs/src/lib.rs
index 4288464f..88c73e74 100644
--- a/libcc2rs/src/lib.rs
+++ b/libcc2rs/src/lib.rs
@@ -7,6 +7,9 @@ pub use reinterpret::ByteRepr;
 mod rc;
 pub use rc::*;
 
+mod union;
+pub use union::*;
+
 mod fn_ptr;
 pub use fn_ptr::FnPtr;
 
diff --git a/libcc2rs/src/rc.rs b/libcc2rs/src/rc.rs
index ccf2f991..2af0866b 100644
--- a/libcc2rs/src/rc.rs
+++ b/libcc2rs/src/rc.rs
@@ -16,6 +16,13 @@ use crate::reinterpret::{ByteRepr, OriginalAlloc, SingleOriginalAlloc, SliceOrig
 
 pub type Value<T> = Rc<RefCell<T>>;
 
+struct ReinterpretedView {
+    // Pointer to the source of reinterpret
+    alloc: Rc<dyn OriginalAlloc>,
+    // C++ byte size of one viewed value
+    byte_size: usize,
+}
+
 #[derive(Default)]
 enum PtrKind<T> {
     #[default]
@@ -25,7 +32,7 @@ enum PtrKind<T> {
     HeapSingle(Weak<RefCell<T>>),
     HeapArray(Weak<RefCell<Box<[T]>>>),
     Vec(Weak<RefCell<Vec<T>>>),
-    Reinterpreted(Rc<dyn OriginalAlloc>),
+    Reinterpreted(Rc<ReinterpretedView>),
 }
 
 pub enum StrongPtr<T> {
@@ -41,6 +48,7 @@ pub enum StrongPtr<T> {
     Reinterpreted {
         alloc: Rc<dyn OriginalAlloc>,
         byte_offset: usize,
+        byte_size: usize,
         // Local buffer for deref(). None until first access.
         // Read-through: refreshed from alloc on every deref() call.
         cell: RefCell<Option<T>>,
@@ -56,10 +64,11 @@ impl<T: ByteRepr> StrongPtr<T> {
             StrongPtr::Reinterpreted {
                 alloc,
                 byte_offset,
+                byte_size,
                 cell,
             } => {
                 // Read-through: always re-read from the original allocation.
-                let mut buf = vec![0u8; std::mem::size_of::<T>()];
+                let mut buf = vec![0u8; *byte_size];
                 alloc.read_bytes(*byte_offset, &mut buf);
                 *cell.borrow_mut() = Some(T::from_bytes(&buf));
                 Ref::map(cell.borrow(), |opt| opt.as_ref().unwrap())
@@ -77,8 +86,8 @@ impl<T> fmt::Debug for PtrKind<T> {
             PtrKind::HeapSingle(w) => write!(f, "HeapSingle({:?})", w.as_ptr()),
             PtrKind::StackArray(w) => write!(f, "StackArray({:?})", w.as_ptr()),
             PtrKind::HeapArray(w) => write!(f, "HeapArray({:?})", w.as_ptr()),
-            PtrKind::Reinterpreted(data) => {
-                write!(f, "Reinterpreted(0x{:x})", data.address())
+            PtrKind::Reinterpreted(view) => {
+                write!(f, "Reinterpreted(0x{:x})", view.alloc.address())
             }
         }
     }
@@ -93,7 +102,7 @@ impl<T> Clone for PtrKind<T> {
             PtrKind::HeapSingle(weak) => PtrKind::HeapSingle(weak.clone()),
             PtrKind::StackArray(weak) => PtrKind::StackArray(weak.clone()),
             PtrKind::HeapArray(weak) => PtrKind::HeapArray(weak.clone()),
-            PtrKind::Reinterpreted(data) => PtrKind::Reinterpreted(Rc::clone(data)),
+            PtrKind::Reinterpreted(view) => PtrKind::Reinterpreted(Rc::clone(view)),
         }
     }
 }
@@ -105,7 +114,7 @@ impl<T> PtrKind<T> {
             PtrKind::StackSingle(w) | PtrKind::HeapSingle(w) => w.as_ptr() as usize,
             PtrKind::Vec(w) => w.as_ptr() as usize,
             PtrKind::StackArray(w) | PtrKind::HeapArray(w) => w.as_ptr() as usize,
-            PtrKind::Reinterpreted(data) => data.address(),
+            PtrKind::Reinterpreted(view) => view.alloc.address(),
         }
     }
 }
@@ -251,40 +260,40 @@ impl<T> Ptr<T> {
     #[inline]
     fn elem_step(&self) -> usize {
         match &self.kind {
-            PtrKind::Reinterpreted(_) => std::mem::size_of::<T>(),
+            PtrKind::Reinterpreted(view) => view.byte_size,
             _ => 1,
         }
     }
 
     #[inline]
     pub fn len(&self) -> usize {
-        match self.kind {
+        match &self.kind {
             PtrKind::Null => 0,
             PtrKind::StackSingle(_) | PtrKind::HeapSingle(_) => 1,
-            PtrKind::Vec(ref weak) => weak.upgrade().expect("ub: dangling pointer").borrow().len(),
-            PtrKind::StackArray(ref weak) | PtrKind::HeapArray(ref weak) => {
+            PtrKind::Vec(weak) => weak.upgrade().expect("ub: dangling pointer").borrow().len(),
+            PtrKind::StackArray(weak) | PtrKind::HeapArray(weak) => {
                 weak.upgrade().expect("ub: dangling pointer").borrow().len()
             }
-            PtrKind::Reinterpreted(ref data) => data.total_byte_len() / std::mem::size_of::<T>(),
+            PtrKind::Reinterpreted(view) => view.alloc.total_byte_len() / view.byte_size,
         }
     }
 
     #[inline]
     pub fn is_empty(&self) -> bool {
-        match self.kind {
+        match &self.kind {
             PtrKind::Null => true,
             PtrKind::StackSingle(_) | PtrKind::HeapSingle(_) => false,
-            PtrKind::Vec(ref weak) => weak
+            PtrKind::Vec(weak) => weak
                 .upgrade()
                 .expect("ub: dangling pointer")
                 .borrow()
                 .is_empty(),
-            PtrKind::StackArray(ref weak) | PtrKind::HeapArray(ref weak) => weak
+            PtrKind::StackArray(weak) | PtrKind::HeapArray(weak) => weak
                 .upgrade()
                 .expect("ub: dangling pointer")
                 .borrow()
                 .is_empty(),
-            PtrKind::Reinterpreted(ref data) => self.offset >= data.total_byte_len(),
+            PtrKind::Reinterpreted(view) => self.offset >= view.alloc.total_byte_len(),
         }
     }
 
@@ -339,9 +348,10 @@ impl<T> Ptr<T> {
                 rc: weak.upgrade().expect("ub: dangling pointer"),
                 offset: self.offset,
             },
-            PtrKind::Reinterpreted(data) => StrongPtr::Reinterpreted {
-                alloc: Rc::clone(data),
+            PtrKind::Reinterpreted(view) => StrongPtr::Reinterpreted {
+                alloc: Rc::clone(&view.alloc),
                 byte_offset: self.offset,
+                byte_size: view.byte_size,
                 cell: RefCell::new(None),
             },
         }
@@ -365,10 +375,10 @@ impl<T> Ptr<T> {
                 let rc = weak.upgrade().expect("ub: dangling pointer");
                 rc.borrow_mut()[self.offset] = value;
             }
-            PtrKind::Reinterpreted(data) => {
-                let mut buf = vec![0u8; std::mem::size_of::<T>()];
+            PtrKind::Reinterpreted(view) => {
+                let mut buf = vec![0u8; view.byte_size];
                 value.to_bytes(&mut buf);
-                data.write_bytes(self.offset, &buf);
+                view.alloc.write_bytes(self.offset, &buf);
             }
         }
     }
@@ -391,7 +401,7 @@ impl<T> Ptr<T> {
             return self_any.downcast_ref::<Ptr<U>>().unwrap().clone();
         }
 
-        if std::mem::size_of::<U>() == 0 {
+        if U::byte_size() == 0 {
             panic!("cannot reinterpret_cast to zero-sized type");
         }
 
@@ -399,22 +409,25 @@ impl<T> Ptr<T> {
             PtrKind::Null => return Ptr::null(),
             PtrKind::StackSingle(weak) | PtrKind::HeapSingle(weak) => (
                 Rc::new(SingleOriginalAlloc { weak: weak.clone() }),
-                self.byte_offset(),
+                self.offset.wrapping_mul(T::byte_size()),
             ),
             PtrKind::Vec(weak) => (
                 Rc::new(SliceOriginalAlloc { weak: weak.clone() }),
-                self.byte_offset(),
+                self.offset.wrapping_mul(T::byte_size()),
             ),
             PtrKind::StackArray(weak) | PtrKind::HeapArray(weak) => (
                 Rc::new(SliceOriginalAlloc { weak: weak.clone() }),
-                self.byte_offset(),
+                self.offset.wrapping_mul(T::byte_size()),
             ),
-            PtrKind::Reinterpreted(data) => (Rc::clone(data), self.offset),
+            PtrKind::Reinterpreted(view) => (Rc::clone(&view.alloc), self.offset),
         };
 
         Ptr {
             offset: abs_byte_off,
-            kind: PtrKind::Reinterpreted(alloc),
+            kind: PtrKind::Reinterpreted(Rc::new(ReinterpretedView {
+                alloc,
+                byte_size: U::byte_size(),
+            })),
         }
     }
 }
@@ -441,13 +454,13 @@ impl<T> Ptr<T> {
                 let mut borrow = rc.borrow_mut();
                 f(&mut borrow[self.offset])
             }
-            PtrKind::Reinterpreted(data) => {
-                let mut buf = vec![0u8; std::mem::size_of::<T>()];
-                data.read_bytes(self.offset, &mut buf);
+            PtrKind::Reinterpreted(view) => {
+                let mut buf = vec![0u8; view.byte_size];
+                view.alloc.read_bytes(self.offset, &mut buf);
                 let mut val = T::from_bytes(&buf);
                 let ret = f(&mut val);
                 val.to_bytes(&mut buf);
-                data.write_bytes(self.offset, &buf);
+                view.alloc.write_bytes(self.offset, &buf);
                 ret
             }
         }
@@ -474,9 +487,9 @@ impl<T> Ptr<T> {
                 let borrow = rc.borrow();
                 f(&borrow[self.offset])
             }
-            PtrKind::Reinterpreted(data) => {
-                let mut buf = vec![0u8; std::mem::size_of::<T>()];
-                data.read_bytes(self.offset, &mut buf);
+            PtrKind::Reinterpreted(view) => {
+                let mut buf = vec![0u8; view.byte_size];
+                view.alloc.read_bytes(self.offset, &mut buf);
                 let val = T::from_bytes(&buf);
                 f(&val)
             }
@@ -501,9 +514,9 @@ impl<T: Clone + ByteRepr> Ptr<T> {
             PtrKind::StackArray(ref weak) | PtrKind::HeapArray(ref weak) => {
                 weak.upgrade().expect("ub: dangling pointer").borrow()[self.offset].clone()
             }
-            PtrKind::Reinterpreted(ref data) => {
-                let mut buf = vec![0u8; std::mem::size_of::<T>()];
-                data.read_bytes(self.offset, &mut buf);
+            PtrKind::Reinterpreted(ref view) => {
+                let mut buf = vec![0u8; view.byte_size];
+                view.alloc.read_bytes(self.offset, &mut buf);
                 T::from_bytes(&buf)
             }
         }
@@ -535,7 +548,7 @@ impl<T: std::cmp::Ord> Ptr<T> {
                 let strong = weak.upgrade().expect("ub: dangling pointer");
                 (*strong.borrow_mut())[self.get_offset()..last].sort();
             }
-            PtrKind::Reinterpreted(..) => {
+            PtrKind::Reinterpreted(_) => {
                 panic!("sorting not supported for reinterpreted pointers")
             }
         }
@@ -580,7 +593,7 @@ impl<T: Clone> Ptr<T> {
                 let mut borrow = strong.borrow_mut();
                 sort(&mut borrow, self.get_offset(), last, &mut cmp);
             }
-            PtrKind::Reinterpreted(..) => {
+            PtrKind::Reinterpreted(_) => {
                 panic!("sorting not supported for reinterpreted pointers")
             }
         }
@@ -856,7 +869,7 @@ impl<T> ToOwnedOption<T, T> for Ptr<T> {
             }
             PtrKind::Vec(_) => panic!("Can't own a vector"),
             PtrKind::HeapArray(_) => panic!("Can't own an array variable as single"),
-            PtrKind::Reinterpreted(..) => panic!("Can't own a reinterpreted pointer"),
+            PtrKind::Reinterpreted(_) => panic!("Can't own a reinterpreted pointer"),
         }
     }
 }
@@ -882,7 +895,7 @@ impl<T> ToOwnedOption<T, Box<[T]>> for Ptr<T> {
             }
             PtrKind::Vec(_) => panic!("Can't own a vector"),
             PtrKind::HeapSingle(_) => panic!("Can't own a single variable as an array"),
-            PtrKind::Reinterpreted(..) => panic!("Can't own a reinterpreted pointer"),
+            PtrKind::Reinterpreted(_) => panic!("Can't own a reinterpreted pointer"),
         }
     }
 }
@@ -898,7 +911,7 @@ impl<T> fmt::Debug for Ptr<T> {
                 (Weak::as_ptr(w) as usize).wrapping_add(self.byte_offset())
             }
             PtrKind::Vec(w) => (Weak::as_ptr(w) as usize).wrapping_add(self.byte_offset()),
-            PtrKind::Reinterpreted(data) => data.address().wrapping_add(self.byte_offset()),
+            PtrKind::Reinterpreted(view) => view.alloc.address().wrapping_add(self.byte_offset()),
         };
         write!(f, "0x{:x}", addr)
     }
@@ -994,9 +1007,9 @@ impl Ptr<u8> {
                 let raw = strong.borrow();
                 raw[start..end].to_vec()
             }
-            PtrKind::Reinterpreted(ref data) => {
+            PtrKind::Reinterpreted(ref view) => {
                 let mut buf = vec![0u8; end.wrapping_sub(start)];
-                data.read_bytes(start, &mut buf);
+                view.alloc.read_bytes(start, &mut buf);
                 buf
             }
         }
@@ -1031,11 +1044,17 @@ impl Ptr<u8> {
 }
 
 pub(crate) trait ErasedPtr: std::any::Any {
-    fn pointee_type_id(&self) -> std::any::TypeId;
-    fn memcpy(&self, src: &dyn ErasedPtr, len: usize);
+    fn as_bytes(&self) -> Ptr<u8>;
     fn as_any(&self) -> &dyn std::any::Any;
-    fn equals(&self, other: &dyn ErasedPtr) -> Option<bool>;
+    fn equals(&self, other: &dyn ErasedPtr) -> bool;
     fn is_null(&self) -> bool;
+    fn address(&self) -> usize;
+}
+
+impl PartialEq for dyn ErasedPtr {
+    fn eq(&self, other: &Self) -> bool {
+        self.equals(other)
+    }
 }
 
 impl<T> ErasedPtr for Ptr<T>
@@ -1043,42 +1062,25 @@ where
     T: ByteRepr + 'static,
     Ptr<T>: PartialEq,
 {
-    fn pointee_type_id(&self) -> std::any::TypeId {
-        std::any::TypeId::of::<T>()
-    }
-
-    fn memcpy(&self, src: &dyn ErasedPtr, len: usize) {
-        if self.pointee_type_id() != src.pointee_type_id() {
-            panic!("memcpy: type mismatch");
-        }
-        let src_ptr = src
-            .as_any()
-            .downcast_ref::<Ptr<T>>()
-            .expect("memcpy: downcast to Ptr<T> failed");
-        let dst_bytes: Ptr<u8> = self.reinterpret_cast();
-        let src_bytes: Ptr<u8> = src_ptr.reinterpret_cast();
-        dst_bytes.memcpy(&src_bytes, len);
+    fn as_bytes(&self) -> Ptr<u8> {
+        self.reinterpret_cast::<u8>()
     }
 
     fn as_any(&self) -> &dyn std::any::Any {
         self
     }
 
-    fn equals(&self, other: &dyn ErasedPtr) -> Option<bool> {
-        if self.pointee_type_id() != other.pointee_type_id() {
-            return None;
-        }
-
-        if let Some(other_ptr) = other.as_any().downcast_ref::<Ptr<T>>() {
-            return Some(self == other_ptr);
-        }
-
-        None
+    fn equals(&self, other: &dyn ErasedPtr) -> bool {
+        other.as_any().downcast_ref::<Ptr<T>>() == Some(self)
     }
 
     fn is_null(&self) -> bool {
         Ptr::is_null(self)
     }
+
+    fn address(&self) -> usize {
+        self.kind.address().wrapping_add(self.byte_offset())
+    }
 }
 
 #[derive(Clone)]
@@ -1109,64 +1111,36 @@ impl AnyPtr {
     }
 
     pub fn reinterpret_cast<T: ByteRepr>(&self) -> Ptr<T> {
-        macro_rules! try_src {
-            ($ty:ty) => {{
-                if let Some(p) = self.cast::<$ty>() {
-                    return p.reinterpret_cast::<T>();
-                }
-                if let Some(pv) = self.cast::<Vec<$ty>>() {
-                    return pv.reinterpret_cast::<T>();
-                }
-            }};
+        if self.ptr.is_null() {
+            return Ptr::<T>::null();
         }
-
-        try_src!(u8);
-        try_src!(i8);
-        try_src!(u16);
-        try_src!(i16);
-        try_src!(u32);
-        try_src!(i32);
-        try_src!(u64);
-        try_src!(i64);
-        try_src!(usize);
-        try_src!(isize);
-
-        panic!("reinterpret_cast: unsupported AnyPtr source");
+        if let Some(p) = self.ptr.as_any().downcast_ref::<Ptr<T>>() {
+            return p.clone();
+        }
+        self.ptr.as_bytes().reinterpret_cast::<T>()
     }
 }
 
 impl PartialEq for AnyPtr {
     fn eq(&self, other: &Self) -> bool {
-        let lhs: &dyn ErasedPtr = self.ptr.as_ref();
-        let rhs: &dyn ErasedPtr = other.ptr.as_ref();
-
-        lhs.equals(rhs).unwrap_or_default()
+        *self.ptr == *other.ptr
     }
 }
 
 impl AnyPtr {
     pub fn memcpy(&self, src: &AnyPtr, len: usize) {
-        let dst_erased = &*self.ptr;
-        let src_erased = &*src.ptr;
-
-        if dst_erased.pointee_type_id() == src_erased.pointee_type_id() {
-            dst_erased.memcpy(src_erased, len);
-            return;
-        }
-
-        let dst_u8: Ptr<u8> = self.reinterpret_cast();
-        let src_u8: Ptr<u8> = src.reinterpret_cast();
+        let dst_u8 = self.ptr.as_bytes();
+        let src_u8 = src.ptr.as_bytes();
         dst_u8.memcpy(&src_u8, len);
     }
 
     pub fn memset(&self, value: u8, num: usize) {
-        let dst_u8: Ptr<u8> = self.reinterpret_cast();
-        dst_u8.memset(value, num);
+        self.ptr.as_bytes().memset(value, num);
     }
 
     pub fn memcmp(&self, other: &AnyPtr, len: usize) -> i32 {
-        let a: Ptr<u8> = self.reinterpret_cast();
-        let b: Ptr<u8> = other.reinterpret_cast();
+        let a = self.ptr.as_bytes();
+        let b = other.ptr.as_bytes();
         a.memcmp(&b, len)
     }
 }
@@ -1244,7 +1218,86 @@ impl<T: ?Sized> AsPointerDyn<T> for Rc<RefCell<T>> {
     }
 }
 
-impl<T: 'static> ByteRepr for Ptr<T> {}
+thread_local! {
+    // address -> the live pointer at that address (key 0 is null, never stored)
+    static PTR_REGISTRY: RefCell<HashMap<usize, AnyPtr>> = RefCell::new(HashMap::new());
+}
+
+fn register_ptr(ptr: AnyPtr) -> usize {
+    let addr = ptr.ptr.address();
+    PTR_REGISTRY.with(|reg| reg.borrow_mut().insert(addr, ptr));
+    addr
+}
+
+fn lookup_ptr(addr: usize) -> AnyPtr {
+    PTR_REGISTRY.with(|reg| {
+        reg.borrow()
+            .get(&addr)
+            .cloned()
+            .expect("ub: unregistered pointer")
+    })
+}
+
+fn ptr_to_bytes(addr: usize, buf: &mut [u8]) {
+    buf[..std::mem::size_of::<usize>()].copy_from_slice(&addr.to_ne_bytes());
+}
+
+fn ptr_from_bytes(buf: &[u8]) -> usize {
+    let mut a = [0u8; std::mem::size_of::<usize>()];
+    a.copy_from_slice(&buf[..std::mem::size_of::<usize>()]);
+    usize::from_ne_bytes(a)
+}
+
+impl<T: ByteRepr> ByteRepr for Ptr<T> {
+    fn byte_size() -> usize {
+        std::mem::size_of::<usize>()
+    }
+
+    fn to_bytes(&self, buf: &mut [u8]) {
+        let addr = if self.is_null() { 0 } else { register_ptr(self.clone().to_any()) };
+        ptr_to_bytes(addr, buf);
+    }
+
+    fn from_bytes(buf: &[u8]) -> Self {
+        let addr = ptr_from_bytes(buf);
+        if addr == 0 {
+            return Ptr::null();
+        }
+        lookup_ptr(addr).reinterpret_cast::<T>()
+    }
+}
+
+impl ByteRepr for AnyPtr {
+    fn byte_size() -> usize {
+        std::mem::size_of::<usize>()
+    }
+
+    fn to_bytes(&self, buf: &mut [u8]) {
+        let addr = if self.ptr.is_null() { 0 } else { register_ptr(self.clone()) };
+        ptr_to_bytes(addr, buf);
+    }
+
+    fn from_bytes(buf: &[u8]) -> Self {
+        let addr = ptr_from_bytes(buf);
+        if addr == 0 {
+            return AnyPtr::default();
+        }
+        lookup_ptr(addr)
+    }
+}
+
+impl<T> Ptr<T> {
+    pub(crate) fn reinterpreted_sized(
+        alloc: Rc<dyn OriginalAlloc>,
+        byte_offset: usize,
+        byte_size: usize,
+    ) -> Self {
+        Ptr {
+            offset: byte_offset,
+            kind: PtrKind::Reinterpreted(Rc::new(ReinterpretedView { alloc, byte_size })),
+        }
+    }
+}
 
 #[cfg(test)]
 mod tests {
diff --git a/libcc2rs/src/reinterpret.rs b/libcc2rs/src/reinterpret.rs
index 452b35de..afb34376 100644
--- a/libcc2rs/src/reinterpret.rs
+++ b/libcc2rs/src/reinterpret.rs
@@ -4,20 +4,39 @@
 use std::{cell::RefCell, rc::Weak};
 
 pub trait ByteRepr: 'static {
+    fn byte_size() -> usize
+    where
+        Self: Sized,
+    {
+        panic!(
+            "byte_size is not implemented for {}",
+            std::any::type_name::<Self>()
+        )
+    }
     fn to_bytes(&self, _buf: &mut [u8]) {
-        panic!("ByteRepr not supported for this type");
+        panic!(
+            "to_bytes is not implemented for {}",
+            std::any::type_name::<Self>()
+        )
     }
     fn from_bytes(_buf: &[u8]) -> Self
     where
         Self: Sized,
     {
-        panic!("ByteRepr not supported for this type");
+        panic!(
+            "from_bytes is not implemented for {}",
+            std::any::type_name::<Self>()
+        )
     }
 }
 
 macro_rules! impl_byte_repr {
     ($ty:ty) => {
         impl ByteRepr for $ty {
+            #[inline]
+            fn byte_size() -> usize {
+                std::mem::size_of::<$ty>()
+            }
             #[inline]
             fn to_bytes(&self, buf: &mut [u8]) {
                 buf.copy_from_slice(&self.to_ne_bytes());
@@ -46,6 +65,10 @@ impl_byte_repr!(f32);
 impl_byte_repr!(f64);
 
 impl ByteRepr for bool {
+    #[inline]
+    fn byte_size() -> usize {
+        1
+    }
     #[inline]
     fn to_bytes(&self, buf: &mut [u8]) {
         buf[0] = *self as u8;
@@ -62,7 +85,22 @@ impl<T: ByteRepr> ByteRepr for Vec<T> {}
 impl<T: ByteRepr> ByteRepr for Option<T> {}
 impl<T: ByteRepr> ByteRepr for std::rc::Rc<T> {}
 impl<T: ByteRepr> ByteRepr for std::cell::RefCell<T> {}
-impl<T: ByteRepr> ByteRepr for Box<[T]> {}
+impl<T: ByteRepr> ByteRepr for Box<[T]> {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        let size = std::mem::size_of::<T>();
+        for (i, elem) in self.iter().enumerate() {
+            elem.to_bytes(&mut buf[i * size..(i + 1) * size]);
+        }
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        let size = std::mem::size_of::<T>();
+        let n = buf.len() / size;
+        (0..n)
+            .map(|i| T::from_bytes(&buf[i * size..(i + 1) * size]))
+            .collect::<Vec<T>>()
+            .into_boxed_slice()
+    }
+}
 impl<T: ByteRepr> ByteRepr for Box<T> {}
 impl<T: 'static> ByteRepr for *const T {}
 impl<T: 'static> ByteRepr for *mut T {}
@@ -83,7 +121,7 @@ pub trait OriginalAlloc {
 // Only serializes the overlapping elements, not the whole slice.
 fn slice_read_bytes<S: ByteRepr>(slice: &[S], byte_offset: usize, buf: &mut [u8]) {
     let len = buf.len();
-    let elem_size = std::mem::size_of::<S>();
+    let elem_size = S::byte_size();
     let first_elem = byte_offset / elem_size;
     let last_elem = (byte_offset + len).div_ceil(elem_size);
     let tmp_len = (last_elem - first_elem) * elem_size;
@@ -98,7 +136,7 @@ fn slice_read_bytes<S: ByteRepr>(slice: &[S], byte_offset: usize, buf: &mut [u8]
 // Write `data` at `byte_offset` into a slice of S elements.
 // Only deserializes/reserializes the overlapping elements.
 fn slice_write_bytes<S: ByteRepr>(slice: &mut [S], byte_offset: usize, data: &[u8]) {
-    let elem_size = std::mem::size_of::<S>();
+    let elem_size = S::byte_size();
     let mut elem_buf = vec![0u8; elem_size];
     let first_elem = byte_offset / elem_size;
     let num_elem = data.len().div_ceil(elem_size);
@@ -136,7 +174,7 @@ impl<T: ByteRepr> OriginalAlloc for SingleOriginalAlloc<T> {
     }
 
     fn total_byte_len(&self) -> usize {
-        std::mem::size_of::<T>()
+        T::byte_size()
     }
 
     fn address(&self) -> usize {
@@ -190,7 +228,7 @@ impl<T: AsSlice + 'static> OriginalAlloc for SliceOriginalAlloc<T> {
     fn total_byte_len(&self) -> usize {
         let rc = self.weak.upgrade().expect("ub: dangling pointer");
         let val = rc.borrow();
-        std::mem::size_of_val(val.as_slice())
+        val.as_slice().len() * <T::Elem as ByteRepr>::byte_size()
     }
 
     fn address(&self) -> usize {
diff --git a/libcc2rs/src/union.rs b/libcc2rs/src/union.rs
new file mode 100644
index 00000000..f3d17ab7
--- /dev/null
+++ b/libcc2rs/src/union.rs
@@ -0,0 +1,45 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use std::{cell::RefCell, rc::Rc};
+
+use crate::Ptr;
+use crate::reinterpret::{ByteRepr, OriginalAlloc, SliceOriginalAlloc};
+
+pub struct UnionStorage {
+    bytes: Rc<RefCell<Vec<u8>>>,
+}
+
+impl UnionStorage {
+    pub fn new(size: usize) -> Self {
+        UnionStorage {
+            bytes: Rc::new(RefCell::new(vec![0u8; size])),
+        }
+    }
+
+    pub fn reinterpret_sized<T>(&self, start: usize, end: usize) -> Ptr<T> {
+        let alloc: Rc<dyn OriginalAlloc> = Rc::new(SliceOriginalAlloc {
+            weak: Rc::downgrade(&self.bytes),
+        });
+        Ptr::reinterpreted_sized(alloc, start, end - start)
+    }
+}
+
+impl Clone for UnionStorage {
+    fn clone(&self) -> Self {
+        UnionStorage {
+            bytes: Rc::new(RefCell::new(self.bytes.borrow().clone())),
+        }
+    }
+}
+
+impl ByteRepr for UnionStorage {
+    fn to_bytes(&self, buf: &mut [u8]) {
+        buf.copy_from_slice(&self.bytes.borrow());
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        UnionStorage {
+            bytes: Rc::new(RefCell::new(buf.to_vec())),
+        }
+    }
+}
diff --git a/tests/multi-file/cross_tu_anon_enum_collision/out/refcount/cross_tu_anon_enum_collision.rs b/tests/multi-file/cross_tu_anon_enum_collision/out/refcount/cross_tu_anon_enum_collision.rs
index c7edae33..a7d41726 100644
--- a/tests/multi-file/cross_tu_anon_enum_collision/out/refcount/cross_tu_anon_enum_collision.rs
+++ b/tests/multi-file/cross_tu_anon_enum_collision/out/refcount/cross_tu_anon_enum_collision.rs
@@ -20,6 +20,17 @@ impl From<i32> for anon_0 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_0);
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_0>::from(i32::from_bytes(buf))
+    }
+}
 pub fn a_value_1() -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(0));
     (*x.borrow_mut()) |= (anon_0::ALPHA as i32);
@@ -47,6 +58,17 @@ impl From<i32> for anon_3 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_3);
+impl ByteRepr for anon_3 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_3>::from(i32::from_bytes(buf))
+    }
+}
 pub fn b_value_2() -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(0));
     (*x.borrow_mut()) |= (anon_3::BETA as i32);
diff --git a/tests/multi-file/cross_tu_tag_collision/out/refcount/cross_tu_tag_collision.rs b/tests/multi-file/cross_tu_tag_collision/out/refcount/cross_tu_tag_collision.rs
index 5fd97a8f..f68bcfba 100644
--- a/tests/multi-file/cross_tu_tag_collision/out/refcount/cross_tu_tag_collision.rs
+++ b/tests/multi-file/cross_tu_tag_collision/out/refcount/cross_tu_tag_collision.rs
@@ -11,6 +11,9 @@ pub struct widget {
     pub id: Value<i32>,
 }
 impl ByteRepr for widget {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.id.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -51,6 +54,17 @@ impl From<i32> for widget_enum {
     }
 }
 libcc2rs::impl_enum_inc_dec!(widget_enum);
+impl ByteRepr for widget_enum {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <widget_enum>::from(i32::from_bytes(buf))
+    }
+}
 pub fn b_value_1() -> i32 {
     let w: Value<widget_enum> = Rc::new(RefCell::new(widget_enum::WIDGET_C));
     return ((*w.borrow()) as i32).clone();
diff --git a/tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs b/tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs
index db3db41a..ffd206e2 100644
--- a/tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs
+++ b/tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs
@@ -11,7 +11,21 @@ pub struct container {
     pub p: Value<Ptr<opaque>>,
     pub x: Value<i32>,
 }
-impl ByteRepr for container {}
+impl ByteRepr for container {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.p.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.x.borrow()).to_bytes(&mut buf[8..12]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            p: Rc::new(RefCell::new(<Ptr<opaque>>::from_bytes(&buf[0..8]))),
+            x: Rc::new(RefCell::new(<i32>::from_bytes(&buf[8..12]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -33,3 +47,4 @@ pub fn touch_0(c: Ptr<container>) {
     (*(*(*c.borrow()).upgrade().deref()).p.borrow()).clone();
 }
 pub struct opaque;
+impl ByteRepr for opaque {}
diff --git a/tests/ub/out/refcount/enum_out_of_range_cast.rs b/tests/ub/out/refcount/enum_out_of_range_cast.rs
index 60538ac8..463b825e 100644
--- a/tests/ub/out/refcount/enum_out_of_range_cast.rs
+++ b/tests/ub/out/refcount/enum_out_of_range_cast.rs
@@ -24,6 +24,17 @@ impl From<i32> for Color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Color);
+impl ByteRepr for Color {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Color>::from(i32::from_bytes(buf))
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/ub/out/refcount/enum_out_of_range_increment.rs b/tests/ub/out/refcount/enum_out_of_range_increment.rs
index 4809fa73..7dffcf97 100644
--- a/tests/ub/out/refcount/enum_out_of_range_increment.rs
+++ b/tests/ub/out/refcount/enum_out_of_range_increment.rs
@@ -24,6 +24,17 @@ impl From<i32> for color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(color);
+impl ByteRepr for color {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <color>::from(i32::from_bytes(buf))
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/10_struct.rs b/tests/unit/out/refcount/10_struct.rs
index 2bc298dc..52b05821 100644
--- a/tests/unit/out/refcount/10_struct.rs
+++ b/tests/unit/out/refcount/10_struct.rs
@@ -20,7 +20,21 @@ impl Clone for GraphNode {
         this
     }
 }
-impl ByteRepr for GraphNode {}
+impl ByteRepr for GraphNode {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.dst.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.next.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            dst: Rc::new(RefCell::new(<u32>::from_bytes(&buf[0..4]))),
+            next: Rc::new(RefCell::new(<Ptr<GraphNode>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct Graph {
     pub V: Value<u32>,
@@ -59,7 +73,21 @@ impl Clone for Graph {
         this
     }
 }
-impl ByteRepr for Graph {}
+impl ByteRepr for Graph {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.V.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.adj.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            V: Rc::new(RefCell::new(<u32>::from_bytes(&buf[0..4]))),
+            adj: Rc::new(RefCell::new(<Ptr<Ptr<GraphNode>>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/addr_of_global.rs b/tests/unit/out/refcount/addr_of_global.rs
index 01ddb7f7..e9ee44e9 100644
--- a/tests/unit/out/refcount/addr_of_global.rs
+++ b/tests/unit/out/refcount/addr_of_global.rs
@@ -19,6 +19,9 @@ impl Clone for Inner {
     }
 }
 impl ByteRepr for Inner {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.value.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -40,7 +43,19 @@ impl Clone for Outer {
         this
     }
 }
-impl ByteRepr for Outer {}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.p.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            p: Rc::new(RefCell::new(<Ptr<Inner>>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
 thread_local!(
     pub static alpha_0: Value<Inner> = Rc::new(RefCell::new(Inner {
         value: Rc::new(RefCell::new(1)),
diff --git a/tests/unit/out/refcount/anonymous-struct.rs b/tests/unit/out/refcount/anonymous-struct.rs
index fcd7db80..ad257c16 100644
--- a/tests/unit/out/refcount/anonymous-struct.rs
+++ b/tests/unit/out/refcount/anonymous-struct.rs
@@ -21,6 +21,9 @@ impl Clone for Outer_Named {
     }
 }
 impl ByteRepr for Outer_Named {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.a.borrow()).to_bytes(&mut buf[0..4]);
         (*self.b.borrow()).to_bytes(&mut buf[4..8]);
@@ -47,6 +50,9 @@ impl Clone for anon_0 {
     }
 }
 impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.c.borrow()).to_bytes(&mut buf[0..4]);
         (*self.d.borrow()).to_bytes(&mut buf[4..8]);
@@ -73,6 +79,9 @@ impl Clone for anon_1 {
     }
 }
 impl ByteRepr for anon_1 {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.g.borrow()).to_bytes(&mut buf[0..4]);
         (*self.h.borrow()).to_bytes(&mut buf[4..8]);
@@ -99,6 +108,9 @@ impl Clone for anon_2 {
     }
 }
 impl ByteRepr for anon_2 {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.e.borrow()).to_bytes(&mut buf[0..4]);
         (*self.f.borrow()).to_bytes(&mut buf[4..8]);
@@ -123,6 +135,9 @@ impl Clone for anon_4 {
     }
 }
 impl ByteRepr for anon_4 {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.j.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -145,6 +160,9 @@ impl Clone for anon_5 {
     }
 }
 impl ByteRepr for anon_5 {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.k.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -170,7 +188,23 @@ impl Clone for anon_3 {
         this
     }
 }
-impl ByteRepr for anon_3 {}
+impl ByteRepr for anon_3 {
+    fn byte_size() -> usize {
+        12
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.i.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.inner_named.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.anon_5.borrow()).to_bytes(&mut buf[8..12]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            i: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            inner_named: Rc::new(RefCell::new(<anon_4>::from_bytes(&buf[4..8]))),
+            anon_5: Rc::new(RefCell::new(<anon_5>::from_bytes(&buf[8..12]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct Outer {
     pub named: Value<Outer_Named>,
@@ -191,7 +225,27 @@ impl Clone for Outer {
         this
     }
 }
-impl ByteRepr for Outer {}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        44
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.named.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.anonymous_named_0.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.anonymous_named_1.borrow()).to_bytes(&mut buf[16..24]);
+        (*self.anon_2.borrow()).to_bytes(&mut buf[24..32]);
+        (*self.anon_3.borrow()).to_bytes(&mut buf[32..44]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            named: Rc::new(RefCell::new(<Outer_Named>::from_bytes(&buf[0..8]))),
+            anonymous_named_0: Rc::new(RefCell::new(<anon_0>::from_bytes(&buf[8..16]))),
+            anonymous_named_1: Rc::new(RefCell::new(<anon_1>::from_bytes(&buf[16..24]))),
+            anon_2: Rc::new(RefCell::new(<anon_2>::from_bytes(&buf[24..32]))),
+            anon_3: Rc::new(RefCell::new(<anon_3>::from_bytes(&buf[32..44]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -274,6 +328,9 @@ fn main_0() -> i32 {
         }
     }
     impl ByteRepr for anon_6 {
+        fn byte_size() -> usize {
+            8
+        }
         fn to_bytes(&self, buf: &mut [u8]) {
             (*self.x.borrow()).to_bytes(&mut buf[0..4]);
             (*self.z.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/anonymous-struct_c.rs b/tests/unit/out/refcount/anonymous-struct_c.rs
index 23ce8df8..970d6e99 100644
--- a/tests/unit/out/refcount/anonymous-struct_c.rs
+++ b/tests/unit/out/refcount/anonymous-struct_c.rs
@@ -12,6 +12,9 @@ pub struct Named {
     pub b: Value<i32>,
 }
 impl ByteRepr for Named {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.a.borrow()).to_bytes(&mut buf[0..4]);
         (*self.b.borrow()).to_bytes(&mut buf[4..8]);
@@ -29,6 +32,9 @@ pub struct anon_0 {
     pub d: Value<i32>,
 }
 impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.c.borrow()).to_bytes(&mut buf[0..4]);
         (*self.d.borrow()).to_bytes(&mut buf[4..8]);
@@ -46,6 +52,9 @@ pub struct anon_1 {
     pub h: Value<i32>,
 }
 impl ByteRepr for anon_1 {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.g.borrow()).to_bytes(&mut buf[0..4]);
         (*self.h.borrow()).to_bytes(&mut buf[4..8]);
@@ -63,6 +72,9 @@ pub struct anon_2 {
     pub f: Value<i32>,
 }
 impl ByteRepr for anon_2 {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.e.borrow()).to_bytes(&mut buf[0..4]);
         (*self.f.borrow()).to_bytes(&mut buf[4..8]);
@@ -79,6 +91,9 @@ pub struct anon_4 {
     pub j: Value<i32>,
 }
 impl ByteRepr for anon_4 {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.j.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -93,6 +108,9 @@ pub struct anon_5 {
     pub k: Value<i32>,
 }
 impl ByteRepr for anon_5 {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.k.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -108,7 +126,23 @@ pub struct anon_3 {
     pub inner_named: Value<anon_4>,
     pub anon_5: Value<anon_5>,
 }
-impl ByteRepr for anon_3 {}
+impl ByteRepr for anon_3 {
+    fn byte_size() -> usize {
+        12
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.i.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.inner_named.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.anon_5.borrow()).to_bytes(&mut buf[8..12]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            i: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            inner_named: Rc::new(RefCell::new(<anon_4>::from_bytes(&buf[4..8]))),
+            anon_5: Rc::new(RefCell::new(<anon_5>::from_bytes(&buf[8..12]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct Outer {
     pub named: Value<Named>,
@@ -117,7 +151,27 @@ pub struct Outer {
     pub anon_2: Value<anon_2>,
     pub anon_3: Value<anon_3>,
 }
-impl ByteRepr for Outer {}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        44
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.named.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.anon0.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.anon1.borrow()).to_bytes(&mut buf[16..24]);
+        (*self.anon_2.borrow()).to_bytes(&mut buf[24..32]);
+        (*self.anon_3.borrow()).to_bytes(&mut buf[32..44]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            named: Rc::new(RefCell::new(<Named>::from_bytes(&buf[0..8]))),
+            anon0: Rc::new(RefCell::new(<anon_0>::from_bytes(&buf[8..16]))),
+            anon1: Rc::new(RefCell::new(<anon_1>::from_bytes(&buf[16..24]))),
+            anon_2: Rc::new(RefCell::new(<anon_2>::from_bytes(&buf[24..32]))),
+            anon_3: Rc::new(RefCell::new(<anon_3>::from_bytes(&buf[32..44]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -176,6 +230,9 @@ fn main_0() -> i32 {
         pub z: Value<i32>,
     }
     impl ByteRepr for anon_6 {
+        fn byte_size() -> usize {
+            8
+        }
         fn to_bytes(&self, buf: &mut [u8]) {
             (*self.x.borrow()).to_bytes(&mut buf[0..4]);
             (*self.z.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/anonymous_enum.rs b/tests/unit/out/refcount/anonymous_enum.rs
index 25de7201..f248358e 100644
--- a/tests/unit/out/refcount/anonymous_enum.rs
+++ b/tests/unit/out/refcount/anonymous_enum.rs
@@ -22,6 +22,17 @@ impl From<i32> for anon_0 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_0);
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_0>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_1 {
     #[default]
@@ -38,6 +49,17 @@ impl From<i32> for anon_1 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_1);
+impl ByteRepr for anon_1 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_1>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct S {
     pub a: Value<i32>,
@@ -51,6 +73,9 @@ impl Clone for S {
     }
 }
 impl ByteRepr for S {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.a.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -76,6 +101,17 @@ impl From<i32> for TdEnum {
     }
 }
 libcc2rs::impl_enum_inc_dec!(TdEnum);
+impl ByteRepr for TdEnum {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <TdEnum>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_2 {
     #[default]
@@ -92,6 +128,17 @@ impl From<i32> for anon_2 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_2);
+impl ByteRepr for anon_2 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_2>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct WithAnonField {
     pub a: Value<i32>,
@@ -106,7 +153,21 @@ impl Clone for WithAnonField {
         this
     }
 }
-impl ByteRepr for WithAnonField {}
+impl ByteRepr for WithAnonField {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.a.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.field.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            a: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            field: Rc::new(RefCell::new(<anon_2>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -127,6 +188,17 @@ fn main_0() -> i32 {
         }
     }
     libcc2rs::impl_enum_inc_dec!(anon_3);
+    impl ByteRepr for anon_3 {
+        fn byte_size() -> usize {
+            4
+        }
+        fn to_bytes(&self, buf: &mut [u8]) {
+            (*self as i32).to_bytes(buf);
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            <anon_3>::from(i32::from_bytes(buf))
+        }
+    };
     assert!(((anon_0::FIRST_A as i32) != (anon_0::FIRST_B as i32)));
     assert!(((anon_1::SECOND_A as i32) != (anon_1::SECOND_B as i32)));
     assert!(((anon_3::THIRD_A as i32) != (anon_3::THIRD_B as i32)));
diff --git a/tests/unit/out/refcount/anonymous_enum_c.rs b/tests/unit/out/refcount/anonymous_enum_c.rs
index 772ea6e5..55d55567 100644
--- a/tests/unit/out/refcount/anonymous_enum_c.rs
+++ b/tests/unit/out/refcount/anonymous_enum_c.rs
@@ -22,6 +22,17 @@ impl From<i32> for anon_0 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_0);
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_0>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_1 {
     #[default]
@@ -38,11 +49,25 @@ impl From<i32> for anon_1 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_1);
+impl ByteRepr for anon_1 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_1>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct S {
     pub a: Value<i32>,
 }
 impl ByteRepr for S {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.a.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -68,6 +93,17 @@ impl From<i32> for TdEnum_enum {
     }
 }
 libcc2rs::impl_enum_inc_dec!(TdEnum_enum);
+impl ByteRepr for TdEnum_enum {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <TdEnum_enum>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum anon_2 {
     #[default]
@@ -84,12 +120,37 @@ impl From<i32> for anon_2 {
     }
 }
 libcc2rs::impl_enum_inc_dec!(anon_2);
+impl ByteRepr for anon_2 {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <anon_2>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct WithAnonField {
     pub a: Value<i32>,
     pub field: Value<anon_2>,
 }
-impl ByteRepr for WithAnonField {}
+impl ByteRepr for WithAnonField {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.a.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.field.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            a: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            field: Rc::new(RefCell::new(<anon_2>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -110,6 +171,17 @@ fn main_0() -> i32 {
         }
     }
     libcc2rs::impl_enum_inc_dec!(anon_3);
+    impl ByteRepr for anon_3 {
+        fn byte_size() -> usize {
+            4
+        }
+        fn to_bytes(&self, buf: &mut [u8]) {
+            (*self as i32).to_bytes(buf);
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            <anon_3>::from(i32::from_bytes(buf))
+        }
+    };
     assert!(((((anon_0::FIRST_A as i32) != (anon_0::FIRST_B as i32)) as i32) != 0));
     assert!(((((anon_1::SECOND_A as i32) != (anon_1::SECOND_B as i32)) as i32) != 0));
     assert!(((((anon_3::THIRD_A as i32) != (anon_3::THIRD_B as i32)) as i32) != 0));
diff --git a/tests/unit/out/refcount/array_const_init.rs b/tests/unit/out/refcount/array_const_init.rs
index 784f3a73..7a2cf78d 100644
--- a/tests/unit/out/refcount/array_const_init.rs
+++ b/tests/unit/out/refcount/array_const_init.rs
@@ -25,7 +25,23 @@ impl Default for S {
         }
     }
 }
-impl ByteRepr for S {}
+impl ByteRepr for S {
+    fn byte_size() -> usize {
+        20
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.head.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.tail.borrow()).to_bytes(&mut buf[4..16]);
+        (*self.buf.borrow()).to_bytes(&mut buf[16..20]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            head: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            tail: Rc::new(RefCell::new(<Box<[i32]>>::from_bytes(&buf[4..16]))),
+            buf: Rc::new(RefCell::new(<Box<[u8]>>::from_bytes(&buf[16..20]))),
+        }
+    }
+}
 thread_local!(
     pub static s_0: Value<S> = Rc::new(RefCell::new(S {
         head: Rc::new(RefCell::new(5)),
diff --git a/tests/unit/out/refcount/array_of_noncopy_struct.rs b/tests/unit/out/refcount/array_of_noncopy_struct.rs
index 4af56349..0c91af6d 100644
--- a/tests/unit/out/refcount/array_of_noncopy_struct.rs
+++ b/tests/unit/out/refcount/array_of_noncopy_struct.rs
@@ -20,7 +20,21 @@ impl Clone for NonCopy {
         this
     }
 }
-impl ByteRepr for NonCopy {}
+impl ByteRepr for NonCopy {
+    fn byte_size() -> usize {
+        32
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.data.borrow()).to_bytes(&mut buf[0..24]);
+        (*self.tag.borrow()).to_bytes(&mut buf[24..28]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            data: Rc::new(RefCell::new(<Vec<i32>>::from_bytes(&buf[0..24]))),
+            tag: Rc::new(RefCell::new(<i32>::from_bytes(&buf[24..28]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/bool_condition_enum.rs b/tests/unit/out/refcount/bool_condition_enum.rs
index 1d7dc853..ddc111e8 100644
--- a/tests/unit/out/refcount/bool_condition_enum.rs
+++ b/tests/unit/out/refcount/bool_condition_enum.rs
@@ -24,6 +24,17 @@ impl From<i32> for Code {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Code);
+impl ByteRepr for Code {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Code>::from(i32::from_bytes(buf))
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/bool_condition_enum_c.rs b/tests/unit/out/refcount/bool_condition_enum_c.rs
index f84c1a88..4dc973eb 100644
--- a/tests/unit/out/refcount/bool_condition_enum_c.rs
+++ b/tests/unit/out/refcount/bool_condition_enum_c.rs
@@ -24,6 +24,17 @@ impl From<i32> for Code {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Code);
+impl ByteRepr for Code {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Code>::from(i32::from_bytes(buf))
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/bool_condition_logical.rs b/tests/unit/out/refcount/bool_condition_logical.rs
index 9b340849..f54fa8d9 100644
--- a/tests/unit/out/refcount/bool_condition_logical.rs
+++ b/tests/unit/out/refcount/bool_condition_logical.rs
@@ -24,6 +24,17 @@ impl From<i32> for Code {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Code);
+impl ByteRepr for Code {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Code>::from(i32::from_bytes(buf))
+    }
+}
 thread_local!(
     pub static side_effect_0: Value<i32> = Rc::new(RefCell::new(0));
 );
diff --git a/tests/unit/out/refcount/bool_condition_logical_c.rs b/tests/unit/out/refcount/bool_condition_logical_c.rs
index a878ce93..c7e77840 100644
--- a/tests/unit/out/refcount/bool_condition_logical_c.rs
+++ b/tests/unit/out/refcount/bool_condition_logical_c.rs
@@ -24,6 +24,17 @@ impl From<i32> for Code {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Code);
+impl ByteRepr for Code {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Code>::from(i32::from_bytes(buf))
+    }
+}
 thread_local!(
     pub static side_effect_0: Value<i32> = Rc::new(RefCell::new(0));
 );
diff --git a/tests/unit/out/refcount/bounded_struct_ptr.rs b/tests/unit/out/refcount/bounded_struct_ptr.rs
index 477a71a6..6da5e2fb 100644
--- a/tests/unit/out/refcount/bounded_struct_ptr.rs
+++ b/tests/unit/out/refcount/bounded_struct_ptr.rs
@@ -21,6 +21,9 @@ impl Clone for Foo {
     }
 }
 impl ByteRepr for Foo {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x1.borrow()).to_bytes(&mut buf[0..4]);
         (*self.x2.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/bst.rs b/tests/unit/out/refcount/bst.rs
index bead4d4a..4fd8a5a3 100644
--- a/tests/unit/out/refcount/bst.rs
+++ b/tests/unit/out/refcount/bst.rs
@@ -22,7 +22,23 @@ impl Clone for node_t {
         this
     }
 }
-impl ByteRepr for node_t {}
+impl ByteRepr for node_t {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.left.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.right.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.value.borrow()).to_bytes(&mut buf[16..20]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            left: Rc::new(RefCell::new(<Ptr<node_t>>::from_bytes(&buf[0..8]))),
+            right: Rc::new(RefCell::new(<Ptr<node_t>>::from_bytes(&buf[8..16]))),
+            value: Rc::new(RefCell::new(<i32>::from_bytes(&buf[16..20]))),
+        }
+    }
+}
 pub fn find_0(node: Ptr<node_t>, value: i32) -> Ptr<node_t> {
     let node: Value<Ptr<node_t>> = Rc::new(RefCell::new(node));
     let value: Value<i32> = Rc::new(RefCell::new(value));
diff --git a/tests/unit/out/refcount/c_struct.rs b/tests/unit/out/refcount/c_struct.rs
index 0549baab..174f742b 100644
--- a/tests/unit/out/refcount/c_struct.rs
+++ b/tests/unit/out/refcount/c_struct.rs
@@ -12,6 +12,9 @@ pub struct Point {
     pub y: Value<i32>,
 }
 impl ByteRepr for Point {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
@@ -28,13 +31,41 @@ pub struct Line {
     pub start: Value<Point>,
     pub end: Value<Point>,
 }
-impl ByteRepr for Line {}
+impl ByteRepr for Line {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.start.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.end.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            start: Rc::new(RefCell::new(<Point>::from_bytes(&buf[0..8]))),
+            end: Rc::new(RefCell::new(<Point>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct Node {
     pub value: Value<i32>,
     pub next: Value<Ptr<Node>>,
 }
-impl ByteRepr for Node {}
+impl ByteRepr for Node {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.value.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.next.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            value: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            next: Rc::new(RefCell::new(<Ptr<Node>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum Color {
     #[default]
@@ -53,12 +84,26 @@ impl From<i32> for Color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Color);
+impl ByteRepr for Color {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Color>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct Inner {
     pub a: Value<i32>,
     pub b: Value<i32>,
 }
 impl ByteRepr for Inner {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.a.borrow()).to_bytes(&mut buf[0..4]);
         (*self.b.borrow()).to_bytes(&mut buf[4..8]);
@@ -76,7 +121,23 @@ pub struct Container {
     pub color: Value<Color>,
     pub count: Value<i32>,
 }
-impl ByteRepr for Container {}
+impl ByteRepr for Container {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.inner.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.color.borrow()).to_bytes(&mut buf[8..12]);
+        (*self.count.borrow()).to_bytes(&mut buf[12..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            inner: Rc::new(RefCell::new(<Inner>::from_bytes(&buf[0..8]))),
+            color: Rc::new(RefCell::new(<Color>::from_bytes(&buf[8..12]))),
+            count: Rc::new(RefCell::new(<i32>::from_bytes(&buf[12..16]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/class.rs b/tests/unit/out/refcount/class.rs
index 6bed63d3..ed4161fc 100644
--- a/tests/unit/out/refcount/class.rs
+++ b/tests/unit/out/refcount/class.rs
@@ -56,6 +56,9 @@ impl Clone for Pair {
     }
 }
 impl ByteRepr for Pair {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.first.borrow()).to_bytes(&mut buf[0..4]);
         (*self.second.borrow()).to_bytes(&mut buf[4..8]);
@@ -89,7 +92,21 @@ impl Clone for Route {
         this
     }
 }
-impl ByteRepr for Route {}
+impl ByteRepr for Route {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.path.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.cost.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            path: Rc::new(RefCell::new(<Pair>::from_bytes(&buf[0..8]))),
+            cost: Rc::new(RefCell::new(<f64>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 pub fn RandomRoute_0(route: Ptr<Route>) -> i32 {
     if (((*(*(*route.upgrade().deref()).path.borrow()).first.borrow()) % 2) != 0) {
         return ({
diff --git a/tests/unit/out/refcount/class_templates.rs b/tests/unit/out/refcount/class_templates.rs
index 3cbce86e..183fbd41 100644
--- a/tests/unit/out/refcount/class_templates.rs
+++ b/tests/unit/out/refcount/class_templates.rs
@@ -42,7 +42,19 @@ impl Clone for MyContainer_int_ {
         this
     }
 }
-impl ByteRepr for MyContainer_int_ {}
+impl ByteRepr for MyContainer_int_ {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.vec_.borrow()).to_bytes(&mut buf[0..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            vec_: Rc::new(RefCell::new(<Vec<i32>>::from_bytes(&buf[0..24]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct MyContainer_char_ {
     vec_: Value<Vec<u8>>,
@@ -79,7 +91,19 @@ impl Clone for MyContainer_char_ {
         this
     }
 }
-impl ByteRepr for MyContainer_char_ {}
+impl ByteRepr for MyContainer_char_ {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.vec_.borrow()).to_bytes(&mut buf[0..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            vec_: Rc::new(RefCell::new(<Vec<u8>>::from_bytes(&buf[0..24]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct MyContainer_float_ {
     vec_: Value<Vec<f32>>,
@@ -116,7 +140,19 @@ impl Clone for MyContainer_float_ {
         this
     }
 }
-impl ByteRepr for MyContainer_float_ {}
+impl ByteRepr for MyContainer_float_ {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.vec_.borrow()).to_bytes(&mut buf[0..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            vec_: Rc::new(RefCell::new(<Vec<f32>>::from_bytes(&buf[0..24]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/clone_vs_move.rs b/tests/unit/out/refcount/clone_vs_move.rs
index 9f6ee411..1953e3d9 100644
--- a/tests/unit/out/refcount/clone_vs_move.rs
+++ b/tests/unit/out/refcount/clone_vs_move.rs
@@ -19,6 +19,9 @@ impl Clone for Bar {
     }
 }
 impl ByteRepr for Bar {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.w.borrow()).to_bytes(&mut buf[0..4]);
     }
diff --git a/tests/unit/out/refcount/complex_function.rs b/tests/unit/out/refcount/complex_function.rs
index 07a300f9..21e1714c 100644
--- a/tests/unit/out/refcount/complex_function.rs
+++ b/tests/unit/out/refcount/complex_function.rs
@@ -30,6 +30,9 @@ impl Clone for X1 {
     }
 }
 impl ByteRepr for X1 {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.v.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -74,7 +77,19 @@ impl Clone for X3 {
         this
     }
 }
-impl ByteRepr for X3 {}
+impl ByteRepr for X3 {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<Ptr<X2>>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct X4 {
     pub v: Value<X3>,
@@ -92,7 +107,19 @@ impl Clone for X4 {
         this
     }
 }
-impl ByteRepr for X4 {}
+impl ByteRepr for X4 {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<X3>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/default.rs b/tests/unit/out/refcount/default.rs
index 3f2389c5..0a4447a7 100644
--- a/tests/unit/out/refcount/default.rs
+++ b/tests/unit/out/refcount/default.rs
@@ -45,7 +45,27 @@ impl Default for Pointers {
         }
     }
 }
-impl ByteRepr for Pointers {}
+impl ByteRepr for Pointers {
+    fn byte_size() -> usize {
+        144
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x1.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.x2.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.x3.borrow()).to_bytes(&mut buf[16..56]);
+        (*self.x4.borrow()).to_bytes(&mut buf[56..136]);
+        (*self.x5.borrow()).to_bytes(&mut buf[136..140]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x1: Rc::new(RefCell::new(<Ptr<i32>>::from_bytes(&buf[0..8]))),
+            x2: Rc::new(RefCell::new(<Ptr<i32>>::from_bytes(&buf[8..16]))),
+            x3: Rc::new(RefCell::new(<Box<[Ptr<i32>]>>::from_bytes(&buf[16..56]))),
+            x4: Rc::new(RefCell::new(<Box<[Ptr<i32>]>>::from_bytes(&buf[56..136]))),
+            x5: Rc::new(RefCell::new(<i32>::from_bytes(&buf[136..140]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/default_in_statics.rs b/tests/unit/out/refcount/default_in_statics.rs
index 7936846d..7636013a 100644
--- a/tests/unit/out/refcount/default_in_statics.rs
+++ b/tests/unit/out/refcount/default_in_statics.rs
@@ -20,7 +20,21 @@ impl Clone for Inner {
         this
     }
 }
-impl ByteRepr for Inner {}
+impl ByteRepr for Inner {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.name.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            name: Rc::new(RefCell::new(<Ptr<u8>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 #[derive()]
 pub struct Outer {
     pub p1: Value<Ptr<i32>>,
@@ -65,7 +79,35 @@ impl Default for Outer {
         }
     }
 }
-impl ByteRepr for Outer {}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        88
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.p1.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.p2.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.arr.borrow()).to_bytes(&mut buf[16..40]);
+        (*self.cp.borrow()).to_bytes(&mut buf[40..48]);
+        (*self.pp.borrow()).to_bytes(&mut buf[48..56]);
+        (*self.inner.borrow()).to_bytes(&mut buf[56..72]);
+        (*self.x.borrow()).to_bytes(&mut buf[72..76]);
+        (*self.fn_.borrow()).to_bytes(&mut buf[80..88]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            p1: Rc::new(RefCell::new(<Ptr<i32>>::from_bytes(&buf[0..8]))),
+            p2: Rc::new(RefCell::new(<Ptr<i32>>::from_bytes(&buf[8..16]))),
+            arr: Rc::new(RefCell::new(<Box<[Ptr<i32>]>>::from_bytes(&buf[16..40]))),
+            cp: Rc::new(RefCell::new(<Ptr<u8>>::from_bytes(&buf[40..48]))),
+            pp: Rc::new(RefCell::new(<Ptr<Ptr<i32>>>::from_bytes(&buf[48..56]))),
+            inner: Rc::new(RefCell::new(<Inner>::from_bytes(&buf[56..72]))),
+            x: Rc::new(RefCell::new(<i32>::from_bytes(&buf[72..76]))),
+            fn_: Rc::new(RefCell::new(<FnPtr<fn(i32) -> i32>>::from_bytes(
+                &buf[80..88],
+            ))),
+        }
+    }
+}
 #[derive()]
 pub struct Foo {
     pub s1: Value<Ptr<u8>>,
@@ -97,7 +139,31 @@ impl Default for Foo {
         }
     }
 }
-impl ByteRepr for Foo {}
+impl ByteRepr for Foo {
+    fn byte_size() -> usize {
+        40
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.s1.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.s2.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.fn1.borrow()).to_bytes(&mut buf[16..24]);
+        (*self.fn2.borrow()).to_bytes(&mut buf[24..32]);
+        (*self.n.borrow()).to_bytes(&mut buf[32..36]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            s1: Rc::new(RefCell::new(<Ptr<u8>>::from_bytes(&buf[0..8]))),
+            s2: Rc::new(RefCell::new(<Ptr<u8>>::from_bytes(&buf[8..16]))),
+            fn1: Rc::new(RefCell::new(<FnPtr<fn(i32) -> i32>>::from_bytes(
+                &buf[16..24],
+            ))),
+            fn2: Rc::new(RefCell::new(<FnPtr<fn(i32) -> i32>>::from_bytes(
+                &buf[24..32],
+            ))),
+            n: Rc::new(RefCell::new(<i32>::from_bytes(&buf[32..36]))),
+        }
+    }
+}
 thread_local!(
     pub static static_fn_0: Value<FnPtr<fn(i32) -> i32>> = Rc::new(RefCell::new(FnPtr::null()));
 );
diff --git a/tests/unit/out/refcount/doubly_linked_list.rs b/tests/unit/out/refcount/doubly_linked_list.rs
index ff45aed2..4b66b546 100644
--- a/tests/unit/out/refcount/doubly_linked_list.rs
+++ b/tests/unit/out/refcount/doubly_linked_list.rs
@@ -32,7 +32,23 @@ impl Clone for Node {
         this
     }
 }
-impl ByteRepr for Node {}
+impl ByteRepr for Node {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.val.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.next.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.prev.borrow()).to_bytes(&mut buf[16..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            val: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            next: Rc::new(RefCell::new(<Ptr<Node>>::from_bytes(&buf[8..16]))),
+            prev: Rc::new(RefCell::new(<Ptr<Node>>::from_bytes(&buf[16..24]))),
+        }
+    }
+}
 pub fn Find_0(head: Ptr<Node>, idx: i32) -> Ptr<Node> {
     let head: Value<Ptr<Node>> = Rc::new(RefCell::new(head));
     let idx: Value<i32> = Rc::new(RefCell::new(idx));
diff --git a/tests/unit/out/refcount/enum_default_in_static.rs b/tests/unit/out/refcount/enum_default_in_static.rs
index 96f3bd8e..0c8b8760 100644
--- a/tests/unit/out/refcount/enum_default_in_static.rs
+++ b/tests/unit/out/refcount/enum_default_in_static.rs
@@ -24,12 +24,37 @@ impl From<i32> for Mode {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Mode);
+impl ByteRepr for Mode {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Mode>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct Config {
     pub count: Value<i32>,
     pub mode: Value<Mode>,
 }
-impl ByteRepr for Config {}
+impl ByteRepr for Config {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.count.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.mode.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            count: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            mode: Rc::new(RefCell::new(<Mode>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
 thread_local!(
     pub static config_0: Value<Config> = <Value<Config>>::default();
 );
diff --git a/tests/unit/out/refcount/enum_increment.rs b/tests/unit/out/refcount/enum_increment.rs
index 25a24a2f..a6802f27 100644
--- a/tests/unit/out/refcount/enum_increment.rs
+++ b/tests/unit/out/refcount/enum_increment.rs
@@ -26,6 +26,17 @@ impl From<i32> for color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(color);
+impl ByteRepr for color {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <color>::from(i32::from_bytes(buf))
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/enum_int_interop.rs b/tests/unit/out/refcount/enum_int_interop.rs
index 01a28cd8..137eacf4 100644
--- a/tests/unit/out/refcount/enum_int_interop.rs
+++ b/tests/unit/out/refcount/enum_int_interop.rs
@@ -24,6 +24,17 @@ impl From<i32> for Color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Color);
+impl ByteRepr for Color {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Color>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum Option {
     #[default]
@@ -44,6 +55,17 @@ impl From<i32> for Option {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Option);
+impl ByteRepr for Option {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Option>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum Tag {
     #[default]
@@ -62,6 +84,17 @@ impl From<i32> for Tag {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Tag);
+impl ByteRepr for Tag {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Tag>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct Entry {
     pub name: Value<Ptr<u8>>,
@@ -78,7 +111,23 @@ impl Clone for Entry {
         this
     }
 }
-impl ByteRepr for Entry {}
+impl ByteRepr for Entry {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.name.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.color.borrow()).to_bytes(&mut buf[8..12]);
+        (*self.opt.borrow()).to_bytes(&mut buf[12..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            name: Rc::new(RefCell::new(<Ptr<u8>>::from_bytes(&buf[0..8]))),
+            color: Rc::new(RefCell::new(<Color>::from_bytes(&buf[8..12]))),
+            opt: Rc::new(RefCell::new(<Option>::from_bytes(&buf[12..16]))),
+        }
+    }
+}
 thread_local!(
     pub static global_color_0: Value<Color> = Rc::new(RefCell::new(Color::GREEN));
 );
diff --git a/tests/unit/out/refcount/enum_int_interop_c.rs b/tests/unit/out/refcount/enum_int_interop_c.rs
index decaf0dc..262201bd 100644
--- a/tests/unit/out/refcount/enum_int_interop_c.rs
+++ b/tests/unit/out/refcount/enum_int_interop_c.rs
@@ -24,6 +24,17 @@ impl From<i32> for Color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Color);
+impl ByteRepr for Color {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Color>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum Option {
     #[default]
@@ -44,6 +55,17 @@ impl From<i32> for Option {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Option);
+impl ByteRepr for Option {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Option>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum Tag_enum {
     #[default]
@@ -62,13 +84,40 @@ impl From<i32> for Tag_enum {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Tag_enum);
+impl ByteRepr for Tag_enum {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Tag_enum>::from(i32::from_bytes(buf))
+    }
+}
 #[derive(Default)]
 pub struct Entry {
     pub name: Value<Ptr<u8>>,
     pub color: Value<Color>,
     pub opt: Value<Option>,
 }
-impl ByteRepr for Entry {}
+impl ByteRepr for Entry {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.name.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.color.borrow()).to_bytes(&mut buf[8..12]);
+        (*self.opt.borrow()).to_bytes(&mut buf[12..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            name: Rc::new(RefCell::new(<Ptr<u8>>::from_bytes(&buf[0..8]))),
+            color: Rc::new(RefCell::new(<Color>::from_bytes(&buf[8..12]))),
+            opt: Rc::new(RefCell::new(<Option>::from_bytes(&buf[12..16]))),
+        }
+    }
+}
 thread_local!(
     pub static global_color_0: Value<Color> = Rc::new(RefCell::new(Color::GREEN));
 );
diff --git a/tests/unit/out/refcount/exprs.rs b/tests/unit/out/refcount/exprs.rs
index 6a4a1646..a1b81cd2 100644
--- a/tests/unit/out/refcount/exprs.rs
+++ b/tests/unit/out/refcount/exprs.rs
@@ -19,6 +19,9 @@ impl Clone for X {
     }
 }
 impl ByteRepr for X {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -50,7 +53,21 @@ impl Clone for Y {
         this
     }
 }
-impl ByteRepr for Y {}
+impl ByteRepr for Y {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.p.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x: Rc::new(RefCell::new(<X>::from_bytes(&buf[0..4]))),
+            p: Rc::new(RefCell::new(<Ptr<X>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/fft.rs b/tests/unit/out/refcount/fft.rs
index 7402fbc6..d7d2465d 100644
--- a/tests/unit/out/refcount/fft.rs
+++ b/tests/unit/out/refcount/fft.rs
@@ -21,6 +21,9 @@ impl Clone for Complex {
     }
 }
 impl ByteRepr for Complex {
+    fn byte_size() -> usize {
+        16
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.re.borrow()).to_bytes(&mut buf[0..8]);
         (*self.img.borrow()).to_bytes(&mut buf[8..16]);
diff --git a/tests/unit/out/refcount/fn_ptr.rs b/tests/unit/out/refcount/fn_ptr.rs
index f4a330d1..c49b0bf7 100644
--- a/tests/unit/out/refcount/fn_ptr.rs
+++ b/tests/unit/out/refcount/fn_ptr.rs
@@ -8,7 +8,7 @@ use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn my_foo_0(p: AnyPtr) -> i32 {
     let p: Value<AnyPtr> = Rc::new(RefCell::new(p));
-    return ((*p.borrow()).cast::<i32>().expect("ub:wrong type").read());
+    return ((*p.borrow()).reinterpret_cast::<i32>().read());
 }
 pub fn foo_1(fn_: FnPtr<fn(AnyPtr) -> i32>, pi: Ptr<i32>) -> i32 {
     let fn_: Value<FnPtr<fn(AnyPtr) -> i32>> = Rc::new(RefCell::new(fn_));
diff --git a/tests/unit/out/refcount/fn_ptr_cast.rs b/tests/unit/out/refcount/fn_ptr_cast.rs
index 3ab34704..4e482704 100644
--- a/tests/unit/out/refcount/fn_ptr_cast.rs
+++ b/tests/unit/out/refcount/fn_ptr_cast.rs
@@ -53,7 +53,19 @@ impl Clone for Command {
         this
     }
 }
-impl ByteRepr for Command {}
+impl ByteRepr for Command {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.data.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            data: Rc::new(RefCell::new(<AnyPtr>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
 pub fn test_void_ptr_to_fn_3() {
     let cmd: Value<Command> = Rc::new(RefCell::new(<Command>::default()));
     (*(*cmd.borrow()).data.borrow_mut()) = FnPtr::<fn(i32) -> i32>::new(double_it_0).to_any();
diff --git a/tests/unit/out/refcount/fn_ptr_stable_sort.rs b/tests/unit/out/refcount/fn_ptr_stable_sort.rs
index 5182170f..da7b2e8a 100644
--- a/tests/unit/out/refcount/fn_ptr_stable_sort.rs
+++ b/tests/unit/out/refcount/fn_ptr_stable_sort.rs
@@ -21,6 +21,9 @@ impl Clone for Item {
     }
 }
 impl ByteRepr for Item {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.key.borrow()).to_bytes(&mut buf[0..4]);
         (*self.value.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/fn_ptr_struct.rs b/tests/unit/out/refcount/fn_ptr_struct.rs
index 95d9d840..c7ff0646 100644
--- a/tests/unit/out/refcount/fn_ptr_struct.rs
+++ b/tests/unit/out/refcount/fn_ptr_struct.rs
@@ -28,7 +28,23 @@ impl Default for Handler {
         }
     }
 }
-impl ByteRepr for Handler {}
+impl ByteRepr for Handler {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.tag.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.cb.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            tag: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            cb: Rc::new(RefCell::new(<FnPtr<fn(i32) -> i32>>::from_bytes(
+                &buf[8..16],
+            ))),
+        }
+    }
+}
 pub fn double_it_0(x: i32) -> i32 {
     let x: Value<i32> = Rc::new(RefCell::new(x));
     return ((*x.borrow()) * 2);
diff --git a/tests/unit/out/refcount/fn_ptr_vtable.rs b/tests/unit/out/refcount/fn_ptr_vtable.rs
index 34934d52..f8e2ce3d 100644
--- a/tests/unit/out/refcount/fn_ptr_vtable.rs
+++ b/tests/unit/out/refcount/fn_ptr_vtable.rs
@@ -31,7 +31,27 @@ impl Default for Vtable {
         }
     }
 }
-impl ByteRepr for Vtable {}
+impl ByteRepr for Vtable {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.create.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.get.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.destroy.borrow()).to_bytes(&mut buf[16..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            create: Rc::new(RefCell::new(<FnPtr<fn(i32) -> AnyPtr>>::from_bytes(
+                &buf[0..8],
+            ))),
+            get: Rc::new(RefCell::new(<FnPtr<fn(AnyPtr) -> i32>>::from_bytes(
+                &buf[8..16],
+            ))),
+            destroy: Rc::new(RefCell::new(<FnPtr<fn(AnyPtr)>>::from_bytes(&buf[16..24]))),
+        }
+    }
+}
 thread_local!(
     pub static storage_0: Value<i32> = <Value<i32>>::default();
 );
@@ -42,11 +62,11 @@ pub fn int_create_1(val: i32) -> AnyPtr {
 }
 pub fn int_get_2(p: AnyPtr) -> i32 {
     let p: Value<AnyPtr> = Rc::new(RefCell::new(p));
-    return ((*p.borrow()).cast::<i32>().expect("ub:wrong type").read());
+    return ((*p.borrow()).reinterpret_cast::<i32>().read());
 }
 pub fn int_destroy_3(p: AnyPtr) {
     let p: Value<AnyPtr> = Rc::new(RefCell::new(p));
-    (*p.borrow()).cast::<i32>().expect("ub:wrong type").write(0);
+    (*p.borrow()).reinterpret_cast::<i32>().write(0);
 }
 pub fn main() {
     std::process::exit(main_0());
diff --git a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
index 66c9e892..57c56051 100644
--- a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
+++ b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
@@ -20,7 +20,21 @@ impl Clone for S {
         this
     }
 }
-impl ByteRepr for S {}
+impl ByteRepr for S {
+    fn byte_size() -> usize {
+        32
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..24]);
+        (*self.a.borrow()).to_bytes(&mut buf[24..28]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<Vec<i32>>::from_bytes(&buf[0..24]))),
+            a: Rc::new(RefCell::new(<i32>::from_bytes(&buf[24..28]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/function_overloading.rs b/tests/unit/out/refcount/function_overloading.rs
index 1d43def8..34b67cc0 100644
--- a/tests/unit/out/refcount/function_overloading.rs
+++ b/tests/unit/out/refcount/function_overloading.rs
@@ -63,6 +63,9 @@ impl Clone for Foo {
     }
 }
 impl ByteRepr for Foo {
+    fn byte_size() -> usize {
+        1
+    }
     fn to_bytes(&self, buf: &mut [u8]) {}
     fn from_bytes(buf: &[u8]) -> Self {
         Self {}
diff --git a/tests/unit/out/refcount/global_pointers.rs b/tests/unit/out/refcount/global_pointers.rs
index 13a87d48..39d6e889 100644
--- a/tests/unit/out/refcount/global_pointers.rs
+++ b/tests/unit/out/refcount/global_pointers.rs
@@ -20,7 +20,21 @@ impl Clone for Entry {
         this
     }
 }
-impl ByteRepr for Entry {}
+impl ByteRepr for Entry {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.name.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.p.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            name: Rc::new(RefCell::new(<Ptr<u8>>::from_bytes(&buf[0..8]))),
+            p: Rc::new(RefCell::new(<Ptr<i32>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 thread_local!(
     pub static single_entry_0: Value<Entry> = Rc::new(RefCell::new(Entry {
         name: Rc::new(RefCell::new(Ptr::from_string_literal(b"alone"))),
diff --git a/tests/unit/out/refcount/global_without_initializer.rs b/tests/unit/out/refcount/global_without_initializer.rs
index 51fce351..f1dd9e2a 100644
--- a/tests/unit/out/refcount/global_without_initializer.rs
+++ b/tests/unit/out/refcount/global_without_initializer.rs
@@ -19,6 +19,9 @@ impl Clone for S {
     }
 }
 impl ByteRepr for S {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.a.borrow()).to_bytes(&mut buf[0..4]);
     }
diff --git a/tests/unit/out/refcount/goto_aggregate_default.rs b/tests/unit/out/refcount/goto_aggregate_default.rs
index 4eb6fee0..5b5fb3c8 100644
--- a/tests/unit/out/refcount/goto_aggregate_default.rs
+++ b/tests/unit/out/refcount/goto_aggregate_default.rs
@@ -12,6 +12,9 @@ pub struct Point {
     pub y: Value<i32>,
 }
 impl ByteRepr for Point {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/huffman.rs b/tests/unit/out/refcount/huffman.rs
index 3a2cc168..67d03c33 100644
--- a/tests/unit/out/refcount/huffman.rs
+++ b/tests/unit/out/refcount/huffman.rs
@@ -29,7 +29,25 @@ impl Clone for MinHeapNode {
         this
     }
 }
-impl ByteRepr for MinHeapNode {}
+impl ByteRepr for MinHeapNode {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.data.borrow()).to_bytes(&mut buf[0..1]);
+        (*self.freq.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.left.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.right.borrow()).to_bytes(&mut buf[16..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            data: Rc::new(RefCell::new(<u8>::from_bytes(&buf[0..1]))),
+            freq: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+            left: Rc::new(RefCell::new(<Ptr<MinHeapNode>>::from_bytes(&buf[8..16]))),
+            right: Rc::new(RefCell::new(<Ptr<MinHeapNode>>::from_bytes(&buf[16..24]))),
+        }
+    }
+}
 pub fn Swap_0(a: Ptr<MinHeapNode>, b: Ptr<MinHeapNode>) {
     let t: Value<MinHeapNode> = Rc::new(RefCell::new(MinHeapNode {
         data: Rc::new(RefCell::new((*(*a.upgrade().deref()).data.borrow()))),
@@ -206,7 +224,31 @@ impl MinHeap {
         }
     }
 }
-impl ByteRepr for MinHeap {}
+impl ByteRepr for MinHeap {
+    fn byte_size() -> usize {
+        32
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.size.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.capacity.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.arr.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.next.borrow()).to_bytes(&mut buf[16..20]);
+        (*self.alloc.borrow()).to_bytes(&mut buf[24..32]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            size: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            capacity: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+            arr: Rc::new(RefCell::new(
+                <Option<Value<Box<[Ptr<MinHeapNode>]>>>>::from_bytes(&buf[8..16]),
+            )),
+            next: Rc::new(RefCell::new(<i32>::from_bytes(&buf[16..20]))),
+            alloc: Rc::new(RefCell::new(
+                <Option<Value<Box<[MinHeapNode]>>>>::from_bytes(&buf[24..32]),
+            )),
+        }
+    }
+}
 pub fn AllocMinHeap_1(capacity: i32) -> Option<Value<MinHeap>> {
     let capacity: Value<i32> = Rc::new(RefCell::new(capacity));
     let minHeap: Value<Option<Value<MinHeap>>> =
diff --git a/tests/unit/out/refcount/immutable-deref-on-func-call.rs b/tests/unit/out/refcount/immutable-deref-on-func-call.rs
index 416e1438..84ae55c9 100644
--- a/tests/unit/out/refcount/immutable-deref-on-func-call.rs
+++ b/tests/unit/out/refcount/immutable-deref-on-func-call.rs
@@ -25,6 +25,9 @@ impl Clone for Item {
     }
 }
 impl ByteRepr for Item {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.value.borrow()).to_bytes(&mut buf[0..4]);
     }
diff --git a/tests/unit/out/refcount/implicit_autoref.rs b/tests/unit/out/refcount/implicit_autoref.rs
index 498d9fc0..52a20e63 100644
--- a/tests/unit/out/refcount/implicit_autoref.rs
+++ b/tests/unit/out/refcount/implicit_autoref.rs
@@ -18,7 +18,19 @@ impl Clone for Holder {
         this
     }
 }
-impl ByteRepr for Holder {}
+impl ByteRepr for Holder {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<Vec<i32>>::from_bytes(&buf[0..24]))),
+        }
+    }
+}
 pub fn write_through_0(p: Ptr<i32>) {
     let p: Value<Ptr<i32>> = Rc::new(RefCell::new(p));
     (*p.borrow()).write(42);
diff --git a/tests/unit/out/refcount/init.rs b/tests/unit/out/refcount/init.rs
index f74601da..2fed9750 100644
--- a/tests/unit/out/refcount/init.rs
+++ b/tests/unit/out/refcount/init.rs
@@ -19,6 +19,9 @@ impl Clone for X {
     }
 }
 impl ByteRepr for X {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
     }
diff --git a/tests/unit/out/refcount/kruskal.rs b/tests/unit/out/refcount/kruskal.rs
index d5f88c57..abb97818 100644
--- a/tests/unit/out/refcount/kruskal.rs
+++ b/tests/unit/out/refcount/kruskal.rs
@@ -23,6 +23,9 @@ impl Clone for Edge {
     }
 }
 impl ByteRepr for Edge {
+    fn byte_size() -> usize {
+        16
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.u.borrow()).to_bytes(&mut buf[0..4]);
         (*self.v.borrow()).to_bytes(&mut buf[4..8]);
@@ -287,14 +290,52 @@ impl DisjointSet {
         }
     }
 }
-impl ByteRepr for DisjointSet {}
+impl ByteRepr for DisjointSet {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.rank.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.parent.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.n.borrow()).to_bytes(&mut buf[16..20]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            rank: Rc::new(RefCell::new(<Option<Value<Box<[i32]>>>>::from_bytes(
+                &buf[0..8],
+            ))),
+            parent: Rc::new(RefCell::new(<Option<Value<Box<[i32]>>>>::from_bytes(
+                &buf[8..16],
+            ))),
+            n: Rc::new(RefCell::new(<i32>::from_bytes(&buf[16..20]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct Graph {
     pub edges: Value<Option<Value<Box<[Edge]>>>>,
     pub V: Value<i32>,
     pub E: Value<i32>,
 }
-impl ByteRepr for Graph {}
+impl ByteRepr for Graph {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.edges.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.V.borrow()).to_bytes(&mut buf[8..12]);
+        (*self.E.borrow()).to_bytes(&mut buf[12..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            edges: Rc::new(RefCell::new(<Option<Value<Box<[Edge]>>>>::from_bytes(
+                &buf[0..8],
+            ))),
+            V: Rc::new(RefCell::new(<i32>::from_bytes(&buf[8..12]))),
+            E: Rc::new(RefCell::new(<i32>::from_bytes(&buf[12..16]))),
+        }
+    }
+}
 pub fn MSTKruskal_2(graph: Ptr<Graph>) -> f64 {
     ({
         let _arr: Ptr<Option<Value<Box<[Edge]>>>> = (*graph.upgrade().deref()).edges.as_pointer();
diff --git a/tests/unit/out/refcount/linked_list.rs b/tests/unit/out/refcount/linked_list.rs
index 9fe91c8a..c276efab 100644
--- a/tests/unit/out/refcount/linked_list.rs
+++ b/tests/unit/out/refcount/linked_list.rs
@@ -26,7 +26,21 @@ impl Clone for Node {
         this
     }
 }
-impl ByteRepr for Node {}
+impl ByteRepr for Node {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.val.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.next.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            val: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            next: Rc::new(RefCell::new(<Ptr<Node>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 pub fn Find_0(head: Ptr<Node>, idx: i32) -> Ptr<Node> {
     let head: Value<Ptr<Node>> = Rc::new(RefCell::new(head));
     let idx: Value<i32> = Rc::new(RefCell::new(idx));
diff --git a/tests/unit/out/refcount/local_anon_struct_collision.rs b/tests/unit/out/refcount/local_anon_struct_collision.rs
index c4b23e73..d69250d0 100644
--- a/tests/unit/out/refcount/local_anon_struct_collision.rs
+++ b/tests/unit/out/refcount/local_anon_struct_collision.rs
@@ -13,6 +13,9 @@ pub fn first_0() -> i32 {
         pub y: Value<i32>,
     }
     impl ByteRepr for anon_1 {
+        fn byte_size() -> usize {
+            8
+        }
         fn to_bytes(&self, buf: &mut [u8]) {
             (*self.x.borrow()).to_bytes(&mut buf[0..4]);
             (*self.y.borrow()).to_bytes(&mut buf[4..8]);
@@ -36,6 +39,9 @@ pub fn second_2() -> i32 {
         pub b: Value<i64>,
     }
     impl ByteRepr for anon_3 {
+        fn byte_size() -> usize {
+            16
+        }
         fn to_bytes(&self, buf: &mut [u8]) {
             (*self.a.borrow()).to_bytes(&mut buf[0..8]);
             (*self.b.borrow()).to_bytes(&mut buf[8..16]);
diff --git a/tests/unit/out/refcount/memcpy_struct_struct.rs b/tests/unit/out/refcount/memcpy_struct_struct.rs
index 5ccc910e..158e7cff 100644
--- a/tests/unit/out/refcount/memcpy_struct_struct.rs
+++ b/tests/unit/out/refcount/memcpy_struct_struct.rs
@@ -21,6 +21,9 @@ impl Clone for Entry {
     }
 }
 impl ByteRepr for Entry {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.bits.borrow()).to_bytes(&mut buf[0..1]);
         (*self.value.borrow()).to_bytes(&mut buf[2..4]);
@@ -77,9 +80,7 @@ fn main_0() -> i32 {
             .to_any()
             .memcpy(
                 &(((table.as_pointer() as Ptr<Entry>).offset(0 as isize)) as Ptr<Entry>).to_any(),
-                (((*table_size.borrow()) as u64)
-                    .wrapping_mul((::std::mem::size_of::<Entry>() as u64))
-                    as usize) as usize,
+                (((*table_size.borrow()) as u64).wrapping_mul((4usize as u64)) as usize) as usize,
             );
         (((table.as_pointer() as Ptr<Entry>).offset((*table_size.borrow()) as isize)) as Ptr<Entry>)
             .to_any()
diff --git a/tests/unit/out/refcount/nested_structs.rs b/tests/unit/out/refcount/nested_structs.rs
index 491cdf12..febf11a8 100644
--- a/tests/unit/out/refcount/nested_structs.rs
+++ b/tests/unit/out/refcount/nested_structs.rs
@@ -19,6 +19,9 @@ impl Clone for Level0_Level1_1_Level2_1_Level3_1 {
     }
 }
 impl ByteRepr for Level0_Level1_1_Level2_1_Level3_1 {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x1.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -43,6 +46,9 @@ impl Clone for Level0_Level1_1_Level2_1_Level3_2 {
     }
 }
 impl ByteRepr for Level0_Level1_1_Level2_1_Level3_2 {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x1.borrow()).to_bytes(&mut buf[0..4]);
         (*self.x2.borrow()).to_bytes(&mut buf[4..8]);
@@ -67,6 +73,9 @@ impl Clone for Level0_Level1_1_Level2_1 {
     }
 }
 impl ByteRepr for Level0_Level1_1_Level2_1 {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x1.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -89,6 +98,9 @@ impl Clone for Level0_Level1_1 {
     }
 }
 impl ByteRepr for Level0_Level1_1 {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x1.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -113,6 +125,9 @@ impl Clone for Level0_Level1_2 {
     }
 }
 impl ByteRepr for Level0_Level1_2 {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x1.borrow()).to_bytes(&mut buf[0..4]);
         (*self.x2.borrow()).to_bytes(&mut buf[4..8]);
@@ -133,6 +148,9 @@ impl Clone for Level0 {
     }
 }
 impl ByteRepr for Level0 {
+    fn byte_size() -> usize {
+        1
+    }
     fn to_bytes(&self, buf: &mut [u8]) {}
     fn from_bytes(buf: &[u8]) -> Self {
         Self {}
diff --git a/tests/unit/out/refcount/new_bst.rs b/tests/unit/out/refcount/new_bst.rs
index 4469be62..595e2222 100644
--- a/tests/unit/out/refcount/new_bst.rs
+++ b/tests/unit/out/refcount/new_bst.rs
@@ -22,7 +22,23 @@ impl Clone for node_t {
         this
     }
 }
-impl ByteRepr for node_t {}
+impl ByteRepr for node_t {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.left.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.right.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.value.borrow()).to_bytes(&mut buf[16..20]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            left: Rc::new(RefCell::new(<Ptr<node_t>>::from_bytes(&buf[0..8]))),
+            right: Rc::new(RefCell::new(<Ptr<node_t>>::from_bytes(&buf[8..16]))),
+            value: Rc::new(RefCell::new(<i32>::from_bytes(&buf[16..20]))),
+        }
+    }
+}
 pub fn find_0(node: Ptr<node_t>, value: i32) -> Ptr<node_t> {
     let node: Value<Ptr<node_t>> = Rc::new(RefCell::new(node));
     let value: Value<i32> = Rc::new(RefCell::new(value));
diff --git a/tests/unit/out/refcount/new_struct.rs b/tests/unit/out/refcount/new_struct.rs
index 9885653c..05ba3965 100644
--- a/tests/unit/out/refcount/new_struct.rs
+++ b/tests/unit/out/refcount/new_struct.rs
@@ -21,6 +21,9 @@ impl Clone for Pair {
     }
 }
 impl ByteRepr for Pair {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/opaque_forward_decl.rs b/tests/unit/out/refcount/opaque_forward_decl.rs
index 206844e8..ec354de3 100644
--- a/tests/unit/out/refcount/opaque_forward_decl.rs
+++ b/tests/unit/out/refcount/opaque_forward_decl.rs
@@ -11,7 +11,21 @@ pub struct container {
     pub p: Value<Ptr<opaque>>,
     pub x: Value<i32>,
 }
-impl ByteRepr for container {}
+impl ByteRepr for container {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.p.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.x.borrow()).to_bytes(&mut buf[8..12]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            p: Rc::new(RefCell::new(<Ptr<opaque>>::from_bytes(&buf[0..8]))),
+            x: Rc::new(RefCell::new(<i32>::from_bytes(&buf[8..12]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
@@ -24,3 +38,4 @@ fn main_0() -> i32 {
     return ((*(*c.borrow()).x.borrow()) - 42);
 }
 pub struct opaque;
+impl ByteRepr for opaque {}
diff --git a/tests/unit/out/refcount/opaque_then_defined.rs b/tests/unit/out/refcount/opaque_then_defined.rs
index 3ce92afb..b67e2e48 100644
--- a/tests/unit/out/refcount/opaque_then_defined.rs
+++ b/tests/unit/out/refcount/opaque_then_defined.rs
@@ -11,13 +11,41 @@ pub struct list {
     pub head: Value<Ptr<node>>,
     pub size: Value<i32>,
 }
-impl ByteRepr for list {}
+impl ByteRepr for list {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.head.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.size.borrow()).to_bytes(&mut buf[8..12]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            head: Rc::new(RefCell::new(<Ptr<node>>::from_bytes(&buf[0..8]))),
+            size: Rc::new(RefCell::new(<i32>::from_bytes(&buf[8..12]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct node {
     pub value: Value<i32>,
     pub next: Value<Ptr<node>>,
 }
-impl ByteRepr for node {}
+impl ByteRepr for node {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.value.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.next.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            value: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            next: Rc::new(RefCell::new(<Ptr<node>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/operator_less_than.rs b/tests/unit/out/refcount/operator_less_than.rs
index cbf3d70b..94102602 100644
--- a/tests/unit/out/refcount/operator_less_than.rs
+++ b/tests/unit/out/refcount/operator_less_than.rs
@@ -62,6 +62,9 @@ impl Clone for Pair {
     }
 }
 impl ByteRepr for Pair {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/pod.rs b/tests/unit/out/refcount/pod.rs
index 1f095551..7af61324 100644
--- a/tests/unit/out/refcount/pod.rs
+++ b/tests/unit/out/refcount/pod.rs
@@ -23,6 +23,9 @@ impl Clone for POD {
     }
 }
 impl ByteRepr for POD {
+    fn byte_size() -> usize {
+        12
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x1.borrow()).to_bytes(&mut buf[0..4]);
         (*self.x2.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/pointer_array.rs b/tests/unit/out/refcount/pointer_array.rs
index e420db79..c9a4a8be 100644
--- a/tests/unit/out/refcount/pointer_array.rs
+++ b/tests/unit/out/refcount/pointer_array.rs
@@ -29,7 +29,19 @@ impl Default for StackArray {
         }
     }
 }
-impl ByteRepr for StackArray {}
+impl ByteRepr for StackArray {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.arr.borrow()).to_bytes(&mut buf[0..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            arr: Rc::new(RefCell::new(<Box<[Ptr<i32>]>>::from_bytes(&buf[0..24]))),
+        }
+    }
+}
 pub fn IncrementAll_0(s: Ptr<StackArray>) {
     let i: Value<i32> = Rc::new(RefCell::new(0));
     'loop_: while ((*i.borrow()) < 3) {
diff --git a/tests/unit/out/refcount/pointers.rs b/tests/unit/out/refcount/pointers.rs
index 0c4d2b16..826fca3b 100644
--- a/tests/unit/out/refcount/pointers.rs
+++ b/tests/unit/out/refcount/pointers.rs
@@ -35,6 +35,9 @@ impl Clone for Test {
     }
 }
 impl ByteRepr for Test {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
     }
diff --git a/tests/unit/out/refcount/polymorphism.rs b/tests/unit/out/refcount/polymorphism.rs
index b1f4297f..b50c4491 100644
--- a/tests/unit/out/refcount/polymorphism.rs
+++ b/tests/unit/out/refcount/polymorphism.rs
@@ -23,6 +23,9 @@ impl Clone for Dog {
     }
 }
 impl ByteRepr for Dog {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {}
     fn from_bytes(buf: &[u8]) -> Self {
         Self {}
@@ -47,6 +50,9 @@ impl Clone for Cat {
     }
 }
 impl ByteRepr for Cat {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {}
     fn from_bytes(buf: &[u8]) -> Self {
         Self {}
diff --git a/tests/unit/out/refcount/ptr_to_incomplete_struct.rs b/tests/unit/out/refcount/ptr_to_incomplete_struct.rs
index 2c4cf29e..853df2c8 100644
--- a/tests/unit/out/refcount/ptr_to_incomplete_struct.rs
+++ b/tests/unit/out/refcount/ptr_to_incomplete_struct.rs
@@ -13,10 +13,7 @@ fn main_0() -> i32 {
     let fp: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new((libcc2rs::cout()).clone()));
     let p: Value<AnyPtr> = Rc::new(RefCell::new((*fp.borrow()).clone().to_any()));
     let fp2: Value<Ptr<::std::fs::File>> = Rc::new(RefCell::new(
-        ((*p.borrow())
-            .cast::<::std::fs::File>()
-            .expect("ub:wrong type"))
-        .clone(),
+        ((*p.borrow()).reinterpret_cast::<::std::fs::File>()).clone(),
     ));
     assert!(
         ((({
diff --git a/tests/unit/out/refcount/push_emplace_back.rs b/tests/unit/out/refcount/push_emplace_back.rs
index 4a96eafd..a3604b39 100644
--- a/tests/unit/out/refcount/push_emplace_back.rs
+++ b/tests/unit/out/refcount/push_emplace_back.rs
@@ -19,6 +19,9 @@ impl Clone for Chunk {
     }
 }
 impl ByteRepr for Chunk {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.data.borrow()).to_bytes(&mut buf[0..4]);
     }
@@ -42,7 +45,21 @@ impl Clone for Writer {
         this
     }
 }
-impl ByteRepr for Writer {}
+impl ByteRepr for Writer {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.output.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.chunk.borrow()).to_bytes(&mut buf[8..12]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            output: Rc::new(RefCell::new(<Ptr<Vec<Chunk>>>::from_bytes(&buf[0..8]))),
+            chunk: Rc::new(RefCell::new(<Chunk>::from_bytes(&buf[8..12]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct JPEGData {
     pub com_data: Value<Vec<Value<Vec<u8>>>>,
@@ -67,7 +84,23 @@ impl Clone for JPEGData {
         this
     }
 }
-impl ByteRepr for JPEGData {}
+impl ByteRepr for JPEGData {
+    fn byte_size() -> usize {
+        48
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.com_data.borrow()).to_bytes(&mut buf[0..24]);
+        (*self.app_data.borrow()).to_bytes(&mut buf[24..48]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            com_data: Rc::new(RefCell::new(<Vec<Value<Vec<u8>>>>::from_bytes(&buf[0..24]))),
+            app_data: Rc::new(RefCell::new(<Vec<Value<Vec<u8>>>>::from_bytes(
+                &buf[24..48],
+            ))),
+        }
+    }
+}
 pub fn push_param_0(dest: Ptr<Vec<Value<Vec<u8>>>>) {
     let dest: Value<Ptr<Vec<Value<Vec<u8>>>>> = Rc::new(RefCell::new(dest));
     ((*dest.borrow()).to_strong().as_pointer() as Ptr<Vec<Value<Vec<u8>>>>).with_mut(
diff --git a/tests/unit/out/refcount/random.rs b/tests/unit/out/refcount/random.rs
index 3b1057f8..aa0e5a31 100644
--- a/tests/unit/out/refcount/random.rs
+++ b/tests/unit/out/refcount/random.rs
@@ -82,6 +82,9 @@ impl Clone for X1 {
     }
 }
 impl ByteRepr for X1 {
+    fn byte_size() -> usize {
+        1
+    }
     fn to_bytes(&self, buf: &mut [u8]) {}
     fn from_bytes(buf: &[u8]) -> Self {
         Self {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_struct.rs b/tests/unit/out/refcount/reinterpret_cast_struct.rs
index 9e2370a1..1c9e14b5 100644
--- a/tests/unit/out/refcount/reinterpret_cast_struct.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_struct.rs
@@ -21,6 +21,9 @@ impl Clone for Point {
     }
 }
 impl ByteRepr for Point {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/reinterpret_cast_struct_to_struct.rs b/tests/unit/out/refcount/reinterpret_cast_struct_to_struct.rs
index 0f065102..5b5d82c9 100644
--- a/tests/unit/out/refcount/reinterpret_cast_struct_to_struct.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_struct_to_struct.rs
@@ -21,6 +21,9 @@ impl Clone for Point {
     }
 }
 impl ByteRepr for Point {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
@@ -47,6 +50,9 @@ impl Clone for Pair {
     }
 }
 impl ByteRepr for Pair {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.first.borrow()).to_bytes(&mut buf[0..4]);
         (*self.second.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/reserved_keywords.rs b/tests/unit/out/refcount/reserved_keywords.rs
index b670988f..5258cfab 100644
--- a/tests/unit/out/refcount/reserved_keywords.rs
+++ b/tests/unit/out/refcount/reserved_keywords.rs
@@ -93,6 +93,9 @@ impl Clone for S {
     }
 }
 impl ByteRepr for S {
+    fn byte_size() -> usize {
+        152
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.as_.borrow()).to_bytes(&mut buf[0..4]);
         (*self.async_.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/static_var_in_class.rs b/tests/unit/out/refcount/static_var_in_class.rs
index 35e012e7..d08a4f63 100644
--- a/tests/unit/out/refcount/static_var_in_class.rs
+++ b/tests/unit/out/refcount/static_var_in_class.rs
@@ -23,6 +23,9 @@ impl Clone for C {
     }
 }
 impl ByteRepr for C {
+    fn byte_size() -> usize {
+        1
+    }
     fn to_bytes(&self, buf: &mut [u8]) {}
     fn from_bytes(buf: &[u8]) -> Self {
         Self {}
@@ -40,6 +43,9 @@ impl Clone for S {
     }
 }
 impl ByteRepr for S {
+    fn byte_size() -> usize {
+        1
+    }
     fn to_bytes(&self, buf: &mut [u8]) {}
     fn from_bytes(buf: &[u8]) -> Self {
         Self {}
diff --git a/tests/unit/out/refcount/struct_ctor.rs b/tests/unit/out/refcount/struct_ctor.rs
index e0a9d434..6c2fd936 100644
--- a/tests/unit/out/refcount/struct_ctor.rs
+++ b/tests/unit/out/refcount/struct_ctor.rs
@@ -40,6 +40,9 @@ impl Clone for StructWithCtor {
     }
 }
 impl ByteRepr for StructWithCtor {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x1_.borrow()).to_bytes(&mut buf[0..4]);
         (*self.x2_.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/struct_default_ctor.rs b/tests/unit/out/refcount/struct_default_ctor.rs
index 7f8875a9..b8ef2594 100644
--- a/tests/unit/out/refcount/struct_default_ctor.rs
+++ b/tests/unit/out/refcount/struct_default_ctor.rs
@@ -44,7 +44,23 @@ impl Default for WOFF2Params {
         }
     }
 }
-impl ByteRepr for WOFF2Params {}
+impl ByteRepr for WOFF2Params {
+    fn byte_size() -> usize {
+        40
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.extended_metadata.borrow()).to_bytes(&mut buf[0..32]);
+        (*self.brotli_quality.borrow()).to_bytes(&mut buf[32..36]);
+        (*self.allow_transforms.borrow()).to_bytes(&mut buf[36..37]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            extended_metadata: Rc::new(RefCell::new(<Vec<u8>>::from_bytes(&buf[0..32]))),
+            brotli_quality: Rc::new(RefCell::new(<i32>::from_bytes(&buf[32..36]))),
+            allow_transforms: Rc::new(RefCell::new(<bool>::from_bytes(&buf[36..37]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/struct_ptr.rs b/tests/unit/out/refcount/struct_ptr.rs
index 4defc67a..beb54800 100644
--- a/tests/unit/out/refcount/struct_ptr.rs
+++ b/tests/unit/out/refcount/struct_ptr.rs
@@ -19,6 +19,9 @@ impl Clone for XX {
     }
 }
 impl ByteRepr for XX {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
     }
diff --git a/tests/unit/out/refcount/switch_char.rs b/tests/unit/out/refcount/switch_char.rs
index d6513ca2..1fa5e7a6 100644
--- a/tests/unit/out/refcount/switch_char.rs
+++ b/tests/unit/out/refcount/switch_char.rs
@@ -48,6 +48,17 @@ impl From<i32> for Color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Color);
+impl ByteRepr for Color {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Color>::from(i32::from_bytes(buf))
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/switch_enum.rs b/tests/unit/out/refcount/switch_enum.rs
index 661b305b..1cf76f67 100644
--- a/tests/unit/out/refcount/switch_enum.rs
+++ b/tests/unit/out/refcount/switch_enum.rs
@@ -24,6 +24,17 @@ impl From<i32> for Color {
     }
 }
 libcc2rs::impl_enum_inc_dec!(Color);
+impl ByteRepr for Color {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Color>::from(i32::from_bytes(buf))
+    }
+}
 pub fn switch_enum_0(c: Color) -> i32 {
     let c: Value<Color> = Rc::new(RefCell::new(c));
     'switch: {
diff --git a/tests/unit/out/refcount/tag_vs_identifier_collision.rs b/tests/unit/out/refcount/tag_vs_identifier_collision.rs
new file mode 100644
index 00000000..718d685b
--- /dev/null
+++ b/tests/unit/out/refcount/tag_vs_identifier_collision.rs
@@ -0,0 +1,268 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum widget_enum {
+    #[default]
+    MODE_IDLE = 0,
+    MODE_ACTIVE = 1,
+    MODE_DONE = 2,
+}
+impl From<i32> for widget_enum {
+    fn from(n: i32) -> widget_enum {
+        match n {
+            0 => widget_enum::MODE_IDLE,
+            1 => widget_enum::MODE_ACTIVE,
+            2 => widget_enum::MODE_DONE,
+            _ => panic!("invalid widget_enum value: {}", n),
+        }
+    }
+}
+libcc2rs::impl_enum_inc_dec!(widget_enum);
+impl ByteRepr for widget_enum {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <widget_enum>::from(i32::from_bytes(buf))
+    }
+}
+#[derive(Default)]
+pub struct widget {
+    pub id: Value<i32>,
+    pub mode: Value<widget_enum>,
+}
+impl ByteRepr for widget {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.id.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.mode.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            id: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            mode: Rc::new(RefCell::new(<widget_enum>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
+#[derive(Default)]
+pub struct point_struct {
+    pub x: Value<i32>,
+    pub y: Value<i32>,
+}
+impl ByteRepr for point_struct {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.x.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.y.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            x: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            y: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
+#[derive(Clone)]
+pub struct point {
+    __store: libcc2rs::UnionStorage,
+}
+impl point {
+    pub fn whole(&self) -> Ptr<i32> {
+        self.__store.reinterpret_sized(0, 4)
+    }
+    pub fn half(&self) -> Ptr<i16> {
+        self.__store.reinterpret_sized(0, 2)
+    }
+}
+impl Default for point {
+    fn default() -> Self {
+        point {
+            __store: libcc2rs::UnionStorage::new(4),
+        }
+    }
+}
+impl ByteRepr for point {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        point {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Clone)]
+pub struct slot_union {
+    __store: libcc2rs::UnionStorage,
+}
+impl slot_union {
+    pub fn i(&self) -> Ptr<i32> {
+        self.__store.reinterpret_sized(0, 4)
+    }
+    pub fn u(&self) -> Ptr<u32> {
+        self.__store.reinterpret_sized(0, 4)
+    }
+}
+impl Default for slot_union {
+    fn default() -> Self {
+        slot_union {
+            __store: libcc2rs::UnionStorage::new(4),
+        }
+    }
+}
+impl ByteRepr for slot_union {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        slot_union {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum slot {
+    #[default]
+    SLOT_A = 0,
+    SLOT_B = 1,
+}
+impl From<i32> for slot {
+    fn from(n: i32) -> slot {
+        match n {
+            0 => slot::SLOT_A,
+            1 => slot::SLOT_B,
+            _ => panic!("invalid slot value: {}", n),
+        }
+    }
+}
+libcc2rs::impl_enum_inc_dec!(slot);
+impl ByteRepr for slot {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <slot>::from(i32::from_bytes(buf))
+    }
+}
+#[derive(Default)]
+pub struct Inner {
+    pub tag_field: Value<i32>,
+}
+impl ByteRepr for Inner {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.tag_field.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            tag_field: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Outer {
+    pub field: Value<Inner>,
+}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.field.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            field: Rc::new(RefCell::new(<Inner>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Inner_struct {
+    pub typedef_field: Value<i32>,
+}
+impl ByteRepr for Inner_struct {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.typedef_field.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            typedef_field: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+pub fn is_active_0(w: Ptr<widget>) -> i32 {
+    let w: Value<Ptr<widget>> = Rc::new(RefCell::new(w));
+    return (({
+        let _lhs = ((*(*(*w.borrow()).upgrade().deref()).mode.borrow()) as u32).clone();
+        _lhs == ((widget_enum::MODE_ACTIVE as i32) as u32)
+    }) as i32);
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let w: Value<widget> = <Value<widget>>::default();
+    (*(*w.borrow()).id.borrow_mut()) = 7;
+    (*(*w.borrow()).mode.borrow_mut()) = widget_enum::MODE_ACTIVE;
+    assert!(
+        (({
+            let _w: Ptr<widget> = (w.as_pointer());
+            is_active_0(_w)
+        }) != 0)
+    );
+    (*(*w.borrow()).mode.borrow_mut()) = widget_enum::MODE_DONE;
+    assert!(
+        (((((*(*w.borrow()).mode.borrow()) as u32) == ((widget_enum::MODE_DONE as i32) as u32))
+            as i32)
+            != 0)
+    );
+    let p: Value<point_struct> = <Value<point_struct>>::default();
+    (*(*p.borrow()).x.borrow_mut()) = 3;
+    (*(*p.borrow()).y.borrow_mut()) = 4;
+    assert!((((((*(*p.borrow()).x.borrow()) + (*(*p.borrow()).y.borrow())) == 7) as i32) != 0));
+    let up: Value<point> = <Value<point>>::default();
+    (*up.borrow_mut()).whole().write(5);
+    assert!((((((*up.borrow()).whole().read()) == 5) as i32) != 0));
+    let b: Value<slot_union> = <Value<slot_union>>::default();
+    (*b.borrow_mut()).i().write(9);
+    assert!((((((*b.borrow()).i().read()) == 9) as i32) != 0));
+    let e: Value<slot> = Rc::new(RefCell::new(slot::SLOT_B));
+    assert!((((((*e.borrow()) as u32) == ((slot::SLOT_B as i32) as u32)) as i32) != 0));
+    let inner_tag: Value<Inner> = <Value<Inner>>::default();
+    (*(*inner_tag.borrow()).tag_field.borrow_mut()) = 11;
+    assert!(((((*(*inner_tag.borrow()).tag_field.borrow()) == 11) as i32) != 0));
+    let inner_typedef: Value<Inner_struct> = <Value<Inner_struct>>::default();
+    (*(*inner_typedef.borrow()).typedef_field.borrow_mut()) = 22;
+    assert!(((((*(*inner_typedef.borrow()).typedef_field.borrow()) == 22) as i32) != 0));
+    let o: Value<Outer> = <Value<Outer>>::default();
+    (*(*(*o.borrow()).field.borrow()).tag_field.borrow_mut()) = 33;
+    assert!(((((*(*(*o.borrow()).field.borrow()).tag_field.borrow()) == 33) as i32) != 0));
+    return (*(*w.borrow()).id.borrow());
+}
diff --git a/tests/unit/out/refcount/typedef-anon-struct.rs b/tests/unit/out/refcount/typedef-anon-struct.rs
index 251d05d8..80e81458 100644
--- a/tests/unit/out/refcount/typedef-anon-struct.rs
+++ b/tests/unit/out/refcount/typedef-anon-struct.rs
@@ -21,6 +21,9 @@ impl Clone for Outer_RunInfo {
     }
 }
 impl ByteRepr for Outer_RunInfo {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.block_idx.borrow()).to_bytes(&mut buf[0..4]);
         (*self.num_extra_zero_runs.borrow()).to_bytes(&mut buf[4..8]);
@@ -44,7 +47,19 @@ impl Clone for Outer {
         this
     }
 }
-impl ByteRepr for Outer {}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.runs.borrow()).to_bytes(&mut buf[0..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            runs: Rc::new(RefCell::new(<Vec<Outer_RunInfo>>::from_bytes(&buf[0..24]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/union_addrof_external.rs b/tests/unit/out/refcount/union_addrof_external.rs
index c8a203d3..3411393e 100644
--- a/tests/unit/out/refcount/union_addrof_external.rs
+++ b/tests/unit/out/refcount/union_addrof_external.rs
@@ -25,18 +25,74 @@ impl Default for record {
         }
     }
 }
-impl ByteRepr for record {}
-#[derive()]
-pub union anon_0 {
-    pub h: Value<record>,
-    pub raw_: Value<Box<[u8]>>,
+impl ByteRepr for record {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.code.borrow()).to_bytes(&mut buf[0..2]);
+        (*self.lo.borrow()).to_bytes(&mut buf[2..4]);
+        (*self.hi.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.pad.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            code: Rc::new(RefCell::new(<u16>::from_bytes(&buf[0..2]))),
+            lo: Rc::new(RefCell::new(<u16>::from_bytes(&buf[2..4]))),
+            hi: Rc::new(RefCell::new(<u32>::from_bytes(&buf[4..8]))),
+            pad: Rc::new(RefCell::new(<Box<[u8]>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
+#[derive(Clone)]
+pub struct anon_0 {
+    __store: libcc2rs::UnionStorage,
+}
+impl anon_0 {
+    pub fn h(&self) -> Ptr<record> {
+        self.__store.reinterpret_sized(0, 16)
+    }
+    pub fn raw_(&self) -> Ptr<Box<[u8]>> {
+        self.__store.reinterpret_sized(0, 128)
+    }
+}
+impl Default for anon_0 {
+    fn default() -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::new(128),
+        }
+    }
+}
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        128
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
 }
-impl ByteRepr for anon_0 {}
 #[derive(Default)]
 pub struct Container {
     pub view: Value<anon_0>,
 }
-impl ByteRepr for Container {}
+impl ByteRepr for Container {
+    fn byte_size() -> usize {
+        128
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.view.borrow()).to_bytes(&mut buf[0..128]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            view: Rc::new(RefCell::new(<anon_0>::from_bytes(&buf[0..128]))),
+        }
+    }
+}
 pub fn fill_1(out: AnyPtr, cap: usize) {
     let out: Value<AnyPtr> = Rc::new(RefCell::new(out));
     let cap: Value<usize> = Rc::new(RefCell::new(cap));
@@ -67,11 +123,11 @@ pub fn fill_1(out: AnyPtr, cap: usize) {
     (*src.borrow_mut())[(6) as usize] = 0_u8;
     (*src.borrow_mut())[(7) as usize] = 1_u8;
     let n: Value<usize> = Rc::new(RefCell::new(
-        if (((::std::mem::size_of::<[u8; 16]>() < (*cap.borrow())) as i32) != 0) {
-            ::std::mem::size_of::<[u8; 16]>()
+        (if (((::std::mem::size_of::<[u8; 16]>() < (*cap.borrow())) as i32) != 0) {
+            (::std::mem::size_of::<[u8; 16]>() as u64)
         } else {
-            (*cap.borrow())
-        },
+            ((*cap.borrow()) as u64)
+        } as usize),
     ));
     {
         (*out.borrow()).memcpy(
@@ -89,42 +145,47 @@ fn main_0() -> i32 {
     {
         ((c.as_pointer()) as Ptr<Container>)
             .to_any()
-            .memset((0) as u8, ::std::mem::size_of::<Container>() as usize);
+            .memset((0) as u8, 128usize as usize);
         ((c.as_pointer()) as Ptr<Container>).to_any().clone()
     };
     ({
         let _out: AnyPtr = ((*c.borrow()).view.as_pointer()).to_any();
-        let _cap: usize = ::std::mem::size_of::<anon_0>();
+        let _cap: usize = 128usize;
         fill_1(_out, _cap)
     });
     assert!(
-        (((((*(*(*(*c.borrow()).view.borrow()).h.borrow()).code.borrow()) as i32) == 2) as i32)
+        (((((*(*(*(*c.borrow()).view.borrow()).h().upgrade().deref())
+            .code
+            .borrow()) as i32)
+            == 2) as i32)
             != 0)
     );
     assert!(
-        ((((((((*(*(*c.borrow()).view.borrow()).h.borrow()).lo.as_pointer())
-            .to_strong()
-            .as_pointer() as Ptr::<u8>)
-            .offset((0) as isize)
-            .read()) as i32)
+        ((((((((*(*(*c.borrow()).view.borrow()).h().upgrade().deref())
+            .lo
+            .as_pointer())
+        .reinterpret_cast::<u8>())
+        .offset((0) as isize)
+        .read()) as i32)
             == 0) as i32)
             != 0)
     );
     assert!(
-        ((((((((*(*(*c.borrow()).view.borrow()).h.borrow()).lo.as_pointer())
-            .to_strong()
-            .as_pointer() as Ptr::<u8>)
-            .offset((1) as isize)
-            .read()) as i32)
+        ((((((((*(*(*c.borrow()).view.borrow()).h().upgrade().deref())
+            .lo
+            .as_pointer())
+        .reinterpret_cast::<u8>())
+        .offset((1) as isize)
+        .read()) as i32)
             == 80) as i32)
             != 0)
     );
     assert!(
-        (((((*(*(*c.borrow()).view.borrow()).raw_.borrow())[(0) as usize] as i32) == 2) as i32)
+        ((((((*(*c.borrow()).view.borrow()).raw_().read())[(0) as usize] as i32) == 2) as i32)
             != 0)
     );
     assert!(
-        ((((((*(*(*c.borrow()).view.borrow()).raw_.borrow())[(3) as usize] as u8) as i32) == 80)
+        (((((((*(*c.borrow()).view.borrow()).raw_().read())[(3) as usize] as u8) as i32) == 80)
             as i32)
             != 0)
     );
diff --git a/tests/unit/out/refcount/union_basic.rs b/tests/unit/out/refcount/union_basic.rs
new file mode 100644
index 00000000..ac455be8
--- /dev/null
+++ b/tests/unit/out/refcount/union_basic.rs
@@ -0,0 +1,51 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone)]
+pub struct basic {
+    __store: libcc2rs::UnionStorage,
+}
+impl basic {
+    pub fn i(&self) -> Ptr<i32> {
+        self.__store.reinterpret_sized(0, 4)
+    }
+    pub fn f(&self) -> Ptr<f32> {
+        self.__store.reinterpret_sized(0, 4)
+    }
+}
+impl Default for basic {
+    fn default() -> Self {
+        basic {
+            __store: libcc2rs::UnionStorage::new(4),
+        }
+    }
+}
+impl ByteRepr for basic {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        basic {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let u: Value<basic> = <Value<basic>>::default();
+    (*u.borrow_mut()).i().write(42);
+    assert!((((((*u.borrow()).i().read()) == 42) as i32) != 0));
+    (*u.borrow_mut()).f().write(3.140000105E+0);
+    assert!((((((*u.borrow()).f().read()) == 3.140000105E+0) as i32) != 0));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/union_cross_arm_cast.rs b/tests/unit/out/refcount/union_cross_arm_cast.rs
new file mode 100644
index 00000000..1014c279
--- /dev/null
+++ b/tests/unit/out/refcount/union_cross_arm_cast.rs
@@ -0,0 +1,192 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive()]
+pub struct shape_a {
+    pub code: Value<u16>,
+    pub pad: Value<Box<[u8]>>,
+}
+impl Default for shape_a {
+    fn default() -> Self {
+        shape_a {
+            code: <Value<u16>>::default(),
+            pad: Rc::new(RefCell::new(
+                (0..14).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+            )),
+        }
+    }
+}
+impl ByteRepr for shape_a {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.code.borrow()).to_bytes(&mut buf[0..2]);
+        (*self.pad.borrow()).to_bytes(&mut buf[2..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            code: Rc::new(RefCell::new(<u16>::from_bytes(&buf[0..2]))),
+            pad: Rc::new(RefCell::new(<Box<[u8]>>::from_bytes(&buf[2..16]))),
+        }
+    }
+}
+#[derive()]
+pub struct shape_b {
+    pub code: Value<u16>,
+    pub lo: Value<u16>,
+    pub mid: Value<u32>,
+    pub fill: Value<Box<[u8]>>,
+    pub tail: Value<u32>,
+}
+impl Default for shape_b {
+    fn default() -> Self {
+        shape_b {
+            code: <Value<u16>>::default(),
+            lo: <Value<u16>>::default(),
+            mid: <Value<u32>>::default(),
+            fill: Rc::new(RefCell::new(
+                (0..16).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+            )),
+            tail: <Value<u32>>::default(),
+        }
+    }
+}
+impl ByteRepr for shape_b {
+    fn byte_size() -> usize {
+        28
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.code.borrow()).to_bytes(&mut buf[0..2]);
+        (*self.lo.borrow()).to_bytes(&mut buf[2..4]);
+        (*self.mid.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.fill.borrow()).to_bytes(&mut buf[8..24]);
+        (*self.tail.borrow()).to_bytes(&mut buf[24..28]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            code: Rc::new(RefCell::new(<u16>::from_bytes(&buf[0..2]))),
+            lo: Rc::new(RefCell::new(<u16>::from_bytes(&buf[2..4]))),
+            mid: Rc::new(RefCell::new(<u32>::from_bytes(&buf[4..8]))),
+            fill: Rc::new(RefCell::new(<Box<[u8]>>::from_bytes(&buf[8..24]))),
+            tail: Rc::new(RefCell::new(<u32>::from_bytes(&buf[24..28]))),
+        }
+    }
+}
+#[derive(Clone)]
+pub struct anon_0 {
+    __store: libcc2rs::UnionStorage,
+}
+impl anon_0 {
+    pub fn a(&self) -> Ptr<shape_a> {
+        self.__store.reinterpret_sized(0, 16)
+    }
+    pub fn b(&self) -> Ptr<shape_b> {
+        self.__store.reinterpret_sized(0, 28)
+    }
+    pub fn raw_(&self) -> Ptr<Box<[u8]>> {
+        self.__store.reinterpret_sized(0, 64)
+    }
+}
+impl Default for anon_0 {
+    fn default() -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::new(64),
+        }
+    }
+}
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        64
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Container {
+    pub len: Value<u32>,
+    pub u: Value<anon_0>,
+}
+impl ByteRepr for Container {
+    fn byte_size() -> usize {
+        68
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.len.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.u.borrow()).to_bytes(&mut buf[4..68]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            len: Rc::new(RefCell::new(<u32>::from_bytes(&buf[0..4]))),
+            u: Rc::new(RefCell::new(<anon_0>::from_bytes(&buf[4..68]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Container> = <Value<Container>>::default();
+    {
+        ((c.as_pointer()) as Ptr<Container>)
+            .to_any()
+            .memset((0) as u8, 68usize as usize);
+        ((c.as_pointer()) as Ptr<Container>).to_any().clone()
+    };
+    (*(*(*(*c.borrow()).u.borrow()).a().upgrade().deref())
+        .code
+        .borrow_mut()) = 10_u16;
+    (*(*c.borrow()).len.borrow_mut()) = (28usize as u32);
+    (*(*(((*(*c.borrow()).u.borrow()).a())
+        .to_any()
+        .reinterpret_cast::<shape_b>())
+    .upgrade()
+    .deref())
+    .tail
+    .borrow_mut()) = 3735928559_u32;
+    assert!(
+        ((((*(*(*(*c.borrow()).u.borrow()).b().upgrade().deref())
+            .tail
+            .borrow())
+            == 3735928559_u32) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*(*(*c.borrow()).u.borrow()).b().upgrade().deref())
+            .code
+            .borrow()) as i32)
+            == 10) as i32)
+            != 0)
+    );
+    (*(*(*(*c.borrow()).u.borrow()).b().upgrade().deref())
+        .lo
+        .borrow_mut()) = 8080_u16;
+    assert!(
+        ((((((((*(*c.borrow()).u.borrow()).raw_().reinterpret_cast::<u8>())
+            .reinterpret_cast::<u8>())
+        .offset((2) as isize)
+        .read()) as i32)
+            == 144) as i32)
+            != 0)
+    );
+    assert!(
+        ((((((((*(*c.borrow()).u.borrow()).raw_().reinterpret_cast::<u8>())
+            .reinterpret_cast::<u8>())
+        .offset((3) as isize)
+        .read()) as i32)
+            == 31) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/union_memset_memcpy.rs b/tests/unit/out/refcount/union_memset_memcpy.rs
new file mode 100644
index 00000000..58a2c94a
--- /dev/null
+++ b/tests/unit/out/refcount/union_memset_memcpy.rs
@@ -0,0 +1,235 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive()]
+pub struct shape_a {
+    pub code: Value<u16>,
+    pub pad: Value<Box<[u8]>>,
+}
+impl Default for shape_a {
+    fn default() -> Self {
+        shape_a {
+            code: <Value<u16>>::default(),
+            pad: Rc::new(RefCell::new(
+                (0..14).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+            )),
+        }
+    }
+}
+impl ByteRepr for shape_a {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.code.borrow()).to_bytes(&mut buf[0..2]);
+        (*self.pad.borrow()).to_bytes(&mut buf[2..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            code: Rc::new(RefCell::new(<u16>::from_bytes(&buf[0..2]))),
+            pad: Rc::new(RefCell::new(<Box<[u8]>>::from_bytes(&buf[2..16]))),
+        }
+    }
+}
+#[derive()]
+pub struct shape_b {
+    pub code: Value<u16>,
+    pub lo: Value<u16>,
+    pub hi: Value<u32>,
+    pub fill: Value<Box<[u8]>>,
+}
+impl Default for shape_b {
+    fn default() -> Self {
+        shape_b {
+            code: <Value<u16>>::default(),
+            lo: <Value<u16>>::default(),
+            hi: <Value<u32>>::default(),
+            fill: Rc::new(RefCell::new(
+                (0..8).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+            )),
+        }
+    }
+}
+impl ByteRepr for shape_b {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.code.borrow()).to_bytes(&mut buf[0..2]);
+        (*self.lo.borrow()).to_bytes(&mut buf[2..4]);
+        (*self.hi.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.fill.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            code: Rc::new(RefCell::new(<u16>::from_bytes(&buf[0..2]))),
+            lo: Rc::new(RefCell::new(<u16>::from_bytes(&buf[2..4]))),
+            hi: Rc::new(RefCell::new(<u32>::from_bytes(&buf[4..8]))),
+            fill: Rc::new(RefCell::new(<Box<[u8]>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
+#[derive(Clone)]
+pub struct anon_0 {
+    __store: libcc2rs::UnionStorage,
+}
+impl anon_0 {
+    pub fn a(&self) -> Ptr<shape_a> {
+        self.__store.reinterpret_sized(0, 16)
+    }
+    pub fn b(&self) -> Ptr<shape_b> {
+        self.__store.reinterpret_sized(0, 16)
+    }
+    pub fn raw_(&self) -> Ptr<Box<[u8]>> {
+        self.__store.reinterpret_sized(0, 256)
+    }
+}
+impl Default for anon_0 {
+    fn default() -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::new(256),
+        }
+    }
+}
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        256
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Container {
+    pub view: Value<anon_0>,
+}
+impl ByteRepr for Container {
+    fn byte_size() -> usize {
+        256
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.view.borrow()).to_bytes(&mut buf[0..256]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            view: Rc::new(RefCell::new(<anon_0>::from_bytes(&buf[0..256]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<Container> = <Value<Container>>::default();
+    {
+        ((c.as_pointer()) as Ptr<Container>)
+            .to_any()
+            .memset((0) as u8, 256usize as usize);
+        ((c.as_pointer()) as Ptr<Container>).to_any().clone()
+    };
+    assert!(
+        (((((*(*(*(*c.borrow()).view.borrow()).a().upgrade().deref())
+            .code
+            .borrow()) as i32)
+            == 0) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*(*(*c.borrow()).view.borrow()).b().upgrade().deref())
+            .lo
+            .borrow()) as i32)
+            == 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((((((*(*c.borrow()).view.borrow()).raw_().read())[(0) as usize] as i32) == 0) as i32)
+            != 0)
+    );
+    assert!(
+        ((((((*(*c.borrow()).view.borrow()).raw_().read())[(255) as usize] as i32) == 0) as i32)
+            != 0)
+    );
+    let src: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        0_u8,
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+        <u8>::default(),
+    ])));
+    (*src.borrow_mut())[(0) as usize] = 2_u8;
+    (*src.borrow_mut())[(2) as usize] = 80_u8;
+    (*src.borrow_mut())[(3) as usize] = 0_u8;
+    (*src.borrow_mut())[(4) as usize] = 127_u8;
+    (*src.borrow_mut())[(5) as usize] = 0_u8;
+    (*src.borrow_mut())[(6) as usize] = 0_u8;
+    (*src.borrow_mut())[(7) as usize] = 1_u8;
+    let len: Value<usize> = Rc::new(RefCell::new(16_usize));
+    assert!(((((*len.borrow()) <= ::std::mem::size_of::<[u8; 256]>()) as i32) != 0));
+    {
+        (((*(*c.borrow()).view.borrow())
+            .raw_()
+            .reinterpret_cast::<u8>()) as Ptr<u8>)
+            .to_any()
+            .memcpy(
+                &((src.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
+                (*len.borrow()) as usize,
+            );
+        (((*(*c.borrow()).view.borrow())
+            .raw_()
+            .reinterpret_cast::<u8>()) as Ptr<u8>)
+            .to_any()
+            .clone()
+    };
+    assert!(
+        (((((*(*(*(*c.borrow()).view.borrow()).b().upgrade().deref())
+            .code
+            .borrow()) as i32)
+            == 2) as i32)
+            != 0)
+    );
+    assert!(
+        ((((((((*(*(*c.borrow()).view.borrow()).b().upgrade().deref())
+            .lo
+            .as_pointer())
+        .reinterpret_cast::<u8>())
+        .offset((0) as isize)
+        .read()) as i32)
+            == 80) as i32)
+            != 0)
+    );
+    {
+        ((c.as_pointer()) as Ptr<Container>)
+            .to_any()
+            .memset((0) as u8, 256usize as usize);
+        ((c.as_pointer()) as Ptr<Container>).to_any().clone()
+    };
+    assert!(
+        (((((*(*(*(*c.borrow()).view.borrow()).b().upgrade().deref())
+            .code
+            .borrow()) as i32)
+            == 0) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/union_nested.rs b/tests/unit/out/refcount/union_nested.rs
new file mode 100644
index 00000000..bc91925d
--- /dev/null
+++ b/tests/unit/out/refcount/union_nested.rs
@@ -0,0 +1,197 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive()]
+pub struct record {
+    pub code: Value<u16>,
+    pub pad: Value<Box<[u8]>>,
+}
+impl Default for record {
+    fn default() -> Self {
+        record {
+            code: <Value<u16>>::default(),
+            pad: Rc::new(RefCell::new(
+                (0..14).map(|_| <u8>::default()).collect::<Box<[u8]>>(),
+            )),
+        }
+    }
+}
+impl ByteRepr for record {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.code.borrow()).to_bytes(&mut buf[0..2]);
+        (*self.pad.borrow()).to_bytes(&mut buf[2..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            code: Rc::new(RefCell::new(<u16>::from_bytes(&buf[0..2]))),
+            pad: Rc::new(RefCell::new(<Box<[u8]>>::from_bytes(&buf[2..16]))),
+        }
+    }
+}
+#[derive(Clone)]
+pub struct anon_0 {
+    __store: libcc2rs::UnionStorage,
+}
+impl anon_0 {
+    pub fn h(&self) -> Ptr<record> {
+        self.__store.reinterpret_sized(0, 16)
+    }
+    pub fn raw_(&self) -> Ptr<Box<[u8]>> {
+        self.__store.reinterpret_sized(0, 128)
+    }
+}
+impl Default for anon_0 {
+    fn default() -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::new(128),
+        }
+    }
+}
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        128
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Default)]
+pub struct inner {
+    pub view: Value<anon_0>,
+}
+impl ByteRepr for inner {
+    fn byte_size() -> usize {
+        128
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.view.borrow()).to_bytes(&mut buf[0..128]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            view: Rc::new(RefCell::new(<anon_0>::from_bytes(&buf[0..128]))),
+        }
+    }
+}
+#[derive(Clone)]
+pub struct anon_1 {
+    __store: libcc2rs::UnionStorage,
+}
+impl anon_1 {
+    pub fn h(&self) -> Ptr<record> {
+        self.__store.reinterpret_sized(0, 16)
+    }
+    pub fn nested(&self) -> Ptr<inner> {
+        self.__store.reinterpret_sized(0, 128)
+    }
+}
+impl Default for anon_1 {
+    fn default() -> Self {
+        anon_1 {
+            __store: libcc2rs::UnionStorage::new(128),
+        }
+    }
+}
+impl ByteRepr for anon_1 {
+    fn byte_size() -> usize {
+        128
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        anon_1 {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Outer {
+    pub kind: Value<i32>,
+    pub level: Value<i32>,
+    pub variant: Value<i32>,
+    pub len: Value<u32>,
+    pub body: Value<anon_1>,
+}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        144
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.kind.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.level.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.variant.borrow()).to_bytes(&mut buf[8..12]);
+        (*self.len.borrow()).to_bytes(&mut buf[12..16]);
+        (*self.body.borrow()).to_bytes(&mut buf[16..144]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            kind: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            level: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+            variant: Rc::new(RefCell::new(<i32>::from_bytes(&buf[8..12]))),
+            len: Rc::new(RefCell::new(<u32>::from_bytes(&buf[12..16]))),
+            body: Rc::new(RefCell::new(<anon_1>::from_bytes(&buf[16..144]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let ex: Value<Outer> = <Value<Outer>>::default();
+    {
+        ((ex.as_pointer()) as Ptr<Outer>)
+            .to_any()
+            .memset((0) as u8, 144usize as usize);
+        ((ex.as_pointer()) as Ptr<Outer>).to_any().clone()
+    };
+    (*(*ex.borrow()).kind.borrow_mut()) = 2;
+    (*(*ex.borrow()).level.borrow_mut()) = 1;
+    (*(*ex.borrow()).variant.borrow_mut()) = 6;
+    (*(*ex.borrow()).len.borrow_mut()) = (16usize as u32);
+    (*(*(*(*ex.borrow()).body.borrow()).h().upgrade().deref())
+        .code
+        .borrow_mut()) = 2_u16;
+    (*(*(*(*ex.borrow()).body.borrow()).h().upgrade().deref())
+        .pad
+        .borrow_mut())[(0) as usize] = (('X' as i32) as u8);
+    assert!(
+        (((((*(*(*(*ex.borrow()).body.borrow()).h().upgrade().deref())
+            .code
+            .borrow()) as i32)
+            == 2) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*(*(*ex.borrow()).body.borrow()).h().upgrade().deref())
+            .pad
+            .borrow())[(0) as usize] as i32)
+            == ('X' as i32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*(*(*(*(*ex.borrow()).body.borrow()).nested().upgrade().deref())
+            .view
+            .borrow())
+        .h()
+        .upgrade()
+        .deref())
+        .code
+        .borrow()) as i32)
+            == 2) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/union_pointer_pun_address.rs b/tests/unit/out/refcount/union_pointer_pun_address.rs
new file mode 100644
index 00000000..7ecc8959
--- /dev/null
+++ b/tests/unit/out/refcount/union_pointer_pun_address.rs
@@ -0,0 +1,96 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Default)]
+pub struct node_a {
+    pub n: Value<i32>,
+}
+impl ByteRepr for node_a {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.n.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            n: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+#[derive(Default)]
+pub struct node_b {
+    pub data: Value<AnyPtr>,
+    pub next: Value<Ptr<node_b>>,
+}
+impl ByteRepr for node_b {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.data.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.next.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            data: Rc::new(RefCell::new(<AnyPtr>::from_bytes(&buf[0..8]))),
+            next: Rc::new(RefCell::new(<Ptr<node_b>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let a: Value<node_a> = Rc::new(RefCell::new(node_a {
+        n: Rc::new(RefCell::new(123)),
+    }));
+    #[derive(Clone)]
+    pub struct anon_0 {
+        __store: libcc2rs::UnionStorage,
+    }
+    impl anon_0 {
+        pub fn to_a(&self) -> Ptr<Ptr<node_a>> {
+            self.__store.reinterpret_sized(0, 8)
+        }
+        pub fn to_b(&self) -> Ptr<Ptr<node_b>> {
+            self.__store.reinterpret_sized(0, 8)
+        }
+    }
+    impl Default for anon_0 {
+        fn default() -> Self {
+            anon_0 {
+                __store: libcc2rs::UnionStorage::new(8),
+            }
+        }
+    }
+    impl ByteRepr for anon_0 {
+        fn byte_size() -> usize {
+            8
+        }
+        fn to_bytes(&self, buf: &mut [u8]) {
+            self.__store.to_bytes(buf);
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            anon_0 {
+                __store: libcc2rs::UnionStorage::from_bytes(buf),
+            }
+        }
+    };
+    let ptr: Value<anon_0> = <Value<anon_0>>::default();
+    (*ptr.borrow_mut()).to_a().write((a.as_pointer()));
+    let out: Value<Ptr<node_b>> = Rc::new(RefCell::new(((*ptr.borrow()).to_b().read()).clone()));
+    assert!(
+        ((({
+            let _lhs = (*out.borrow()).clone().to_any();
+            _lhs == (a.as_pointer()).to_any()
+        }) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/union_pointer_pun_writethrough.rs b/tests/unit/out/refcount/union_pointer_pun_writethrough.rs
new file mode 100644
index 00000000..430d2165
--- /dev/null
+++ b/tests/unit/out/refcount/union_pointer_pun_writethrough.rs
@@ -0,0 +1,51 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let x: Value<i64> = Rc::new(RefCell::new((-1_i32 as i64)));
+    #[derive(Clone)]
+    pub struct anon_0 {
+        __store: libcc2rs::UnionStorage,
+    }
+    impl anon_0 {
+        pub fn as_unsigned(&self) -> Ptr<Ptr<u64>> {
+            self.__store.reinterpret_sized(0, 8)
+        }
+        pub fn as_signed(&self) -> Ptr<Ptr<i64>> {
+            self.__store.reinterpret_sized(0, 8)
+        }
+    }
+    impl Default for anon_0 {
+        fn default() -> Self {
+            anon_0 {
+                __store: libcc2rs::UnionStorage::new(8),
+            }
+        }
+    }
+    impl ByteRepr for anon_0 {
+        fn byte_size() -> usize {
+            8
+        }
+        fn to_bytes(&self, buf: &mut [u8]) {
+            self.__store.to_bytes(buf);
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            anon_0 {
+                __store: libcc2rs::UnionStorage::from_bytes(buf),
+            }
+        }
+    };
+    let pp: Value<anon_0> = <Value<anon_0>>::default();
+    (*pp.borrow_mut()).as_signed().write((x.as_pointer()));
+    ((*pp.borrow()).as_unsigned().read()).write(42_u64);
+    assert!(((((*x.borrow()) == 42_i64) as i32) != 0));
+    return 0;
+}
diff --git a/tests/unit/out/refcount/union_struct_dual_use.rs b/tests/unit/out/refcount/union_struct_dual_use.rs
new file mode 100644
index 00000000..c5a64d3d
--- /dev/null
+++ b/tests/unit/out/refcount/union_struct_dual_use.rs
@@ -0,0 +1,130 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Default)]
+pub struct Inner {
+    pub a: Value<i32>,
+    pub b: Value<i32>,
+}
+impl ByteRepr for Inner {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.a.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.b.borrow()).to_bytes(&mut buf[4..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            a: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            b: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+        }
+    }
+}
+pub fn sum_inner_0(i: Ptr<Inner>) -> i32 {
+    let i: Value<Ptr<Inner>> = Rc::new(RefCell::new(i));
+    return {
+        let _lhs = (*(*(*i.borrow()).upgrade().deref()).a.borrow());
+        _lhs + (*(*(*i.borrow()).upgrade().deref()).b.borrow())
+    };
+}
+#[derive(Clone)]
+pub struct anon_1 {
+    __store: libcc2rs::UnionStorage,
+}
+impl anon_1 {
+    pub fn inner(&self) -> Ptr<Inner> {
+        self.__store.reinterpret_sized(0, 8)
+    }
+    pub fn raw_(&self) -> Ptr<Box<[u8]>> {
+        self.__store.reinterpret_sized(0, 16)
+    }
+}
+impl Default for anon_1 {
+    fn default() -> Self {
+        anon_1 {
+            __store: libcc2rs::UnionStorage::new(16),
+        }
+    }
+}
+impl ByteRepr for anon_1 {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        anon_1 {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Outer {
+    pub u: Value<anon_1>,
+}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.u.borrow()).to_bytes(&mut buf[0..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            u: Rc::new(RefCell::new(<anon_1>::from_bytes(&buf[0..16]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let standalone: Value<Inner> = <Value<Inner>>::default();
+    (*(*standalone.borrow()).a.borrow_mut()) = 3;
+    (*(*standalone.borrow()).b.borrow_mut()) = 4;
+    assert!(
+        (((({
+            let _i: Ptr<Inner> = (standalone.as_pointer());
+            sum_inner_0(_i)
+        }) == 7) as i32)
+            != 0)
+    );
+    let outer: Value<Outer> = <Value<Outer>>::default();
+    {
+        ((outer.as_pointer()) as Ptr<Outer>)
+            .to_any()
+            .memset((0) as u8, 16usize as usize);
+        ((outer.as_pointer()) as Ptr<Outer>).to_any().clone()
+    };
+    (*(*(*(*outer.borrow()).u.borrow()).inner().upgrade().deref())
+        .a
+        .borrow_mut()) = 3;
+    (*(*(*(*outer.borrow()).u.borrow()).inner().upgrade().deref())
+        .b
+        .borrow_mut()) = 4;
+    assert!(
+        (((({
+            let _i: Ptr<Inner> = ((*(*outer.borrow()).u.borrow()).inner());
+            sum_inner_0(_i)
+        }) == 7) as i32)
+            != 0)
+    );
+    assert!(
+        (((((((*(*outer.borrow()).u.borrow()).raw_().read())[(0) as usize] as u8) as i32) == 3)
+            as i32)
+            != 0)
+    );
+    assert!(
+        (((((((*(*outer.borrow()).u.borrow()).raw_().read())[(4) as usize] as u8) as i32) == 4)
+            as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/union_tagged_simple.rs b/tests/unit/out/refcount/union_tagged_simple.rs
new file mode 100644
index 00000000..9d26b520
--- /dev/null
+++ b/tests/unit/out/refcount/union_tagged_simple.rs
@@ -0,0 +1,120 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Kind_enum {
+    #[default]
+    KIND_NONE = 0,
+    KIND_DONE = 1,
+}
+impl From<i32> for Kind_enum {
+    fn from(n: i32) -> Kind_enum {
+        match n {
+            0 => Kind_enum::KIND_NONE,
+            1 => Kind_enum::KIND_DONE,
+            _ => panic!("invalid Kind_enum value: {}", n),
+        }
+    }
+}
+libcc2rs::impl_enum_inc_dec!(Kind_enum);
+impl ByteRepr for Kind_enum {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Kind_enum>::from(i32::from_bytes(buf))
+    }
+}
+#[derive(Clone)]
+pub struct anon_0 {
+    __store: libcc2rs::UnionStorage,
+}
+impl anon_0 {
+    pub fn obj(&self) -> Ptr<AnyPtr> {
+        self.__store.reinterpret_sized(0, 8)
+    }
+    pub fn code(&self) -> Ptr<i32> {
+        self.__store.reinterpret_sized(0, 4)
+    }
+}
+impl Default for anon_0 {
+    fn default() -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::new(8),
+        }
+    }
+}
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Event {
+    pub kind: Value<Kind_enum>,
+    pub handle: Value<AnyPtr>,
+    pub payload: Value<anon_0>,
+}
+impl ByteRepr for Event {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.kind.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.handle.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.payload.borrow()).to_bytes(&mut buf[16..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            kind: Rc::new(RefCell::new(<Kind_enum>::from_bytes(&buf[0..4]))),
+            handle: Rc::new(RefCell::new(<AnyPtr>::from_bytes(&buf[8..16]))),
+            payload: Rc::new(RefCell::new(<anon_0>::from_bytes(&buf[16..24]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let dummy: Value<i32> = Rc::new(RefCell::new(0));
+    let m1: Value<Event> = <Value<Event>>::default();
+    (*(*m1.borrow()).kind.borrow_mut()) = Kind_enum::KIND_DONE;
+    (*(*m1.borrow()).handle.borrow_mut()) = ((dummy.as_pointer()) as Ptr<i32>).to_any();
+    (*(*m1.borrow()).payload.borrow_mut()).code().write(42);
+    assert!(
+        (((((*(*m1.borrow()).kind.borrow()) as u32) == ((Kind_enum::KIND_DONE as i32) as u32))
+            as i32)
+            != 0)
+    );
+    assert!((((((*(*m1.borrow()).payload.borrow()).code().read()) == 42) as i32) != 0));
+    let m2: Value<Event> = <Value<Event>>::default();
+    (*(*m2.borrow()).kind.borrow_mut()) = Kind_enum::KIND_NONE;
+    (*(*m2.borrow()).handle.borrow_mut()) = ((dummy.as_pointer()) as Ptr<i32>).to_any();
+    (*(*m2.borrow()).payload.borrow_mut())
+        .obj()
+        .write(((dummy.as_pointer()) as Ptr<i32>).to_any());
+    assert!(
+        ((({
+            let _lhs = ((*(*m2.borrow()).payload.borrow()).obj().read()).clone();
+            _lhs == ((dummy.as_pointer()) as Ptr<i32>).to_any()
+        }) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/union_tagged_struct_arms.rs b/tests/unit/out/refcount/union_tagged_struct_arms.rs
new file mode 100644
index 00000000..313bd217
--- /dev/null
+++ b/tests/unit/out/refcount/union_tagged_struct_arms.rs
@@ -0,0 +1,312 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+enum Choice_enum {
+    #[default]
+    C_LIST = 1,
+    C_LETTERS = 2,
+    C_INTEGERS = 3,
+}
+impl From<i32> for Choice_enum {
+    fn from(n: i32) -> Choice_enum {
+        match n {
+            1 => Choice_enum::C_LIST,
+            2 => Choice_enum::C_LETTERS,
+            3 => Choice_enum::C_INTEGERS,
+            _ => panic!("invalid Choice_enum value: {}", n),
+        }
+    }
+}
+libcc2rs::impl_enum_inc_dec!(Choice_enum);
+impl ByteRepr for Choice_enum {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <Choice_enum>::from(i32::from_bytes(buf))
+    }
+}
+#[derive(Default)]
+pub struct anon_1 {
+    pub items: Value<Ptr<Ptr<u8>>>,
+    pub count: Value<i64>,
+    pub cursor: Value<i64>,
+}
+impl ByteRepr for anon_1 {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.items.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.count.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.cursor.borrow()).to_bytes(&mut buf[16..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            items: Rc::new(RefCell::new(<Ptr<Ptr<u8>>>::from_bytes(&buf[0..8]))),
+            count: Rc::new(RefCell::new(<i64>::from_bytes(&buf[8..16]))),
+            cursor: Rc::new(RefCell::new(<i64>::from_bytes(&buf[16..24]))),
+        }
+    }
+}
+#[derive(Default)]
+pub struct anon_2 {
+    pub lo: Value<i32>,
+    pub hi: Value<i32>,
+    pub curr: Value<i32>,
+    pub step: Value<u8>,
+}
+impl ByteRepr for anon_2 {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.lo.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.hi.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.curr.borrow()).to_bytes(&mut buf[8..12]);
+        (*self.step.borrow()).to_bytes(&mut buf[12..13]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            lo: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            hi: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+            curr: Rc::new(RefCell::new(<i32>::from_bytes(&buf[8..12]))),
+            step: Rc::new(RefCell::new(<u8>::from_bytes(&buf[12..13]))),
+        }
+    }
+}
+#[derive(Default)]
+pub struct anon_3 {
+    pub lo: Value<i64>,
+    pub hi: Value<i64>,
+    pub curr: Value<i64>,
+    pub step: Value<i64>,
+    pub width: Value<i32>,
+}
+impl ByteRepr for anon_3 {
+    fn byte_size() -> usize {
+        40
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.lo.borrow()).to_bytes(&mut buf[0..8]);
+        (*self.hi.borrow()).to_bytes(&mut buf[8..16]);
+        (*self.curr.borrow()).to_bytes(&mut buf[16..24]);
+        (*self.step.borrow()).to_bytes(&mut buf[24..32]);
+        (*self.width.borrow()).to_bytes(&mut buf[32..36]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            lo: Rc::new(RefCell::new(<i64>::from_bytes(&buf[0..8]))),
+            hi: Rc::new(RefCell::new(<i64>::from_bytes(&buf[8..16]))),
+            curr: Rc::new(RefCell::new(<i64>::from_bytes(&buf[16..24]))),
+            step: Rc::new(RefCell::new(<i64>::from_bytes(&buf[24..32]))),
+            width: Rc::new(RefCell::new(<i32>::from_bytes(&buf[32..36]))),
+        }
+    }
+}
+#[derive(Clone)]
+pub struct anon_0 {
+    __store: libcc2rs::UnionStorage,
+}
+impl anon_0 {
+    pub fn list(&self) -> Ptr<anon_1> {
+        self.__store.reinterpret_sized(0, 24)
+    }
+    pub fn letters(&self) -> Ptr<anon_2> {
+        self.__store.reinterpret_sized(0, 16)
+    }
+    pub fn integers(&self) -> Ptr<anon_3> {
+        self.__store.reinterpret_sized(0, 40)
+    }
+}
+impl Default for anon_0 {
+    fn default() -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::new(40),
+        }
+    }
+}
+impl ByteRepr for anon_0 {
+    fn byte_size() -> usize {
+        40
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        self.__store.to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        anon_0 {
+            __store: libcc2rs::UnionStorage::from_bytes(buf),
+        }
+    }
+}
+#[derive(Default)]
+pub struct Branch {
+    pub choice: Value<Choice_enum>,
+    pub index: Value<i32>,
+    pub v: Value<anon_0>,
+}
+impl ByteRepr for Branch {
+    fn byte_size() -> usize {
+        48
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.choice.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.index.borrow()).to_bytes(&mut buf[4..8]);
+        (*self.v.borrow()).to_bytes(&mut buf[8..48]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            choice: Rc::new(RefCell::new(<Choice_enum>::from_bytes(&buf[0..4]))),
+            index: Rc::new(RefCell::new(<i32>::from_bytes(&buf[4..8]))),
+            v: Rc::new(RefCell::new(<anon_0>::from_bytes(&buf[8..48]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    thread_local!(
+        static items_4: Value<Box<[Ptr<u8>]>> = Rc::new(RefCell::new(Box::new([
+            Ptr::from_string_literal(b"a"),
+            Ptr::from_string_literal(b"b"),
+            Ptr::from_string_literal(b"c"),
+        ])));
+    );
+    let p_list: Value<Branch> = <Value<Branch>>::default();
+    (*(*p_list.borrow()).choice.borrow_mut()) = Choice_enum::C_LIST;
+    (*(*p_list.borrow()).index.borrow_mut()) = 0;
+    (*(*(*(*p_list.borrow()).v.borrow()).list().upgrade().deref())
+        .items
+        .borrow_mut()) = (items_4.with(Value::clone).as_pointer() as Ptr<Ptr<u8>>);
+    (*(*(*(*p_list.borrow()).v.borrow()).list().upgrade().deref())
+        .count
+        .borrow_mut()) = 3_i64;
+    (*(*(*(*p_list.borrow()).v.borrow()).list().upgrade().deref())
+        .cursor
+        .borrow_mut()) = 1_i64;
+    assert!(
+        ((((*(*(*(*p_list.borrow()).v.borrow()).list().upgrade().deref())
+            .count
+            .borrow())
+            == 3_i64) as i32)
+            != 0)
+    );
+    assert!(
+        (((((((*(*(*(*p_list.borrow()).v.borrow()).list().upgrade().deref())
+            .items
+            .borrow())
+        .offset((1) as isize)
+        .read())
+        .offset((0) as isize)
+        .read()) as i32)
+            == ('b' as i32)) as i32)
+            != 0)
+    );
+    let p_letters: Value<Branch> = <Value<Branch>>::default();
+    (*(*p_letters.borrow()).choice.borrow_mut()) = Choice_enum::C_LETTERS;
+    (*(*p_letters.borrow()).index.borrow_mut()) = 1;
+    (*(*(*(*p_letters.borrow()).v.borrow())
+        .letters()
+        .upgrade()
+        .deref())
+    .lo
+    .borrow_mut()) = ('a' as i32);
+    (*(*(*(*p_letters.borrow()).v.borrow())
+        .letters()
+        .upgrade()
+        .deref())
+    .hi
+    .borrow_mut()) = ('z' as i32);
+    (*(*(*(*p_letters.borrow()).v.borrow())
+        .letters()
+        .upgrade()
+        .deref())
+    .curr
+    .borrow_mut()) = ('m' as i32);
+    (*(*(*(*p_letters.borrow()).v.borrow())
+        .letters()
+        .upgrade()
+        .deref())
+    .step
+    .borrow_mut()) = 1_u8;
+    assert!(
+        (((((*(*(*(*p_letters.borrow()).v.borrow())
+            .letters()
+            .upgrade()
+            .deref())
+        .hi
+        .borrow())
+            - (*(*(*(*p_letters.borrow()).v.borrow())
+                .letters()
+                .upgrade()
+                .deref())
+            .lo
+            .borrow()))
+            == 25) as i32)
+            != 0)
+    );
+    let p_integers: Value<Branch> = <Value<Branch>>::default();
+    (*(*p_integers.borrow()).choice.borrow_mut()) = Choice_enum::C_INTEGERS;
+    (*(*p_integers.borrow()).index.borrow_mut()) = 2;
+    (*(*(*(*p_integers.borrow()).v.borrow())
+        .integers()
+        .upgrade()
+        .deref())
+    .lo
+    .borrow_mut()) = 1_i64;
+    (*(*(*(*p_integers.borrow()).v.borrow())
+        .integers()
+        .upgrade()
+        .deref())
+    .hi
+    .borrow_mut()) = 100_i64;
+    (*(*(*(*p_integers.borrow()).v.borrow())
+        .integers()
+        .upgrade()
+        .deref())
+    .curr
+    .borrow_mut()) = 1_i64;
+    (*(*(*(*p_integers.borrow()).v.borrow())
+        .integers()
+        .upgrade()
+        .deref())
+    .step
+    .borrow_mut()) = 1_i64;
+    (*(*(*(*p_integers.borrow()).v.borrow())
+        .integers()
+        .upgrade()
+        .deref())
+    .width
+    .borrow_mut()) = 3;
+    assert!(
+        ((((*(*(*(*p_integers.borrow()).v.borrow())
+            .integers()
+            .upgrade()
+            .deref())
+        .hi
+        .borrow())
+            == 100_i64) as i32)
+            != 0)
+    );
+    assert!(
+        ((((*(*(*(*p_integers.borrow()).v.borrow())
+            .integers()
+            .upgrade()
+            .deref())
+        .width
+        .borrow())
+            == 3) as i32)
+            != 0)
+    );
+    return 0;
+}
diff --git a/tests/unit/out/refcount/unique_ptr.rs b/tests/unit/out/refcount/unique_ptr.rs
index 1bcfc3e4..f7559906 100644
--- a/tests/unit/out/refcount/unique_ptr.rs
+++ b/tests/unit/out/refcount/unique_ptr.rs
@@ -15,7 +15,19 @@ impl SafePointer {
         (*(*self.ptr.borrow_mut()).as_ref().unwrap().borrow_mut()).prefix_inc();
     }
 }
-impl ByteRepr for SafePointer {}
+impl ByteRepr for SafePointer {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.ptr.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            ptr: Rc::new(RefCell::new(<Option<Value<i32>>>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
 #[derive(Default)]
 pub struct Pair {
     pub x: Value<i32>,
@@ -31,6 +43,9 @@ impl Clone for Pair {
     }
 }
 impl ByteRepr for Pair {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/unique_ptr_const_deref.rs b/tests/unit/out/refcount/unique_ptr_const_deref.rs
index d1598432..a860f6fd 100644
--- a/tests/unit/out/refcount/unique_ptr_const_deref.rs
+++ b/tests/unit/out/refcount/unique_ptr_const_deref.rs
@@ -10,7 +10,19 @@ use std::rc::{Rc, Weak};
 pub struct Holder {
     pub val: Value<Option<Value<i32>>>,
 }
-impl ByteRepr for Holder {}
+impl ByteRepr for Holder {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.val.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            val: Rc::new(RefCell::new(<Option<Value<i32>>>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
 pub fn read_val_0(h: Ptr<Holder>) -> i32 {
     let h: Value<Ptr<Holder>> = Rc::new(RefCell::new(h));
     return (*(*(*(*h.borrow()).upgrade().deref()).val.borrow())
diff --git a/tests/unit/out/refcount/unique_ptr_nested.rs b/tests/unit/out/refcount/unique_ptr_nested.rs
index 94cfb1d5..73a07682 100644
--- a/tests/unit/out/refcount/unique_ptr_nested.rs
+++ b/tests/unit/out/refcount/unique_ptr_nested.rs
@@ -21,6 +21,9 @@ impl Clone for Inner {
     }
 }
 impl ByteRepr for Inner {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
@@ -36,7 +39,19 @@ impl ByteRepr for Inner {
 pub struct Outer {
     pub inner: Value<Option<Value<Inner>>>,
 }
-impl ByteRepr for Outer {}
+impl ByteRepr for Outer {
+    fn byte_size() -> usize {
+        8
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.inner.borrow()).to_bytes(&mut buf[0..8]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            inner: Rc::new(RefCell::new(<Option<Value<Inner>>>::from_bytes(&buf[0..8]))),
+        }
+    }
+}
 pub fn main() {
     std::process::exit(main_0());
 }
diff --git a/tests/unit/out/refcount/unique_ptr_struct.rs b/tests/unit/out/refcount/unique_ptr_struct.rs
index db2e7df6..7ed4daf1 100644
--- a/tests/unit/out/refcount/unique_ptr_struct.rs
+++ b/tests/unit/out/refcount/unique_ptr_struct.rs
@@ -21,6 +21,9 @@ impl Clone for Point {
     }
 }
 impl ByteRepr for Point {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.x.borrow()).to_bytes(&mut buf[0..4]);
         (*self.y.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs b/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs
index e62b86ee..593f2409 100644
--- a/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs
+++ b/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs
@@ -11,7 +11,21 @@ pub struct node {
     pub data: Value<i32>,
     pub next: Value<Ptr<node>>,
 }
-impl ByteRepr for node {}
+impl ByteRepr for node {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.data.borrow()).to_bytes(&mut buf[0..4]);
+        (*self.next.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            data: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+            next: Rc::new(RefCell::new(<Ptr<node>>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
 #[derive(Clone, Copy, PartialEq, Debug, Default)]
 enum opt {
     #[default]
@@ -32,6 +46,17 @@ impl From<i32> for opt {
     }
 }
 libcc2rs::impl_enum_inc_dec!(opt);
+impl ByteRepr for opt {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self as i32).to_bytes(buf);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        <opt>::from(i32::from_bytes(buf))
+    }
+}
 pub fn dispatch_0(option: i32, __args: &[VaArg]) -> i32 {
     let option: Value<i32> = Rc::new(RefCell::new(option));
     let ap: Value<VaList> = Rc::new(RefCell::new(VaList::default()));
@@ -100,10 +125,7 @@ fn main_0() -> i32 {
             let _option: i32 = (opt::OPT_FILE as i32);
             dispatch_0(
                 _option,
-                &[((AnyPtr::default())
-                    .cast::<::std::fs::File>()
-                    .expect("ub:wrong type"))
-                .into()],
+                &[((AnyPtr::default()).reinterpret_cast::<::std::fs::File>()).into()],
             )
         }) == 0) as i32)
             != 0)
diff --git a/tests/unit/out/refcount/va_arg_struct_ctx.rs b/tests/unit/out/refcount/va_arg_struct_ctx.rs
index bc607d65..aea69a5e 100644
--- a/tests/unit/out/refcount/va_arg_struct_ctx.rs
+++ b/tests/unit/out/refcount/va_arg_struct_ctx.rs
@@ -12,6 +12,9 @@ pub struct context {
     pub last_error: Value<i32>,
 }
 impl ByteRepr for context {
+    fn byte_size() -> usize {
+        8
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.verbose.borrow()).to_bytes(&mut buf[0..4]);
         (*self.last_error.borrow()).to_bytes(&mut buf[4..8]);
diff --git a/tests/unit/out/refcount/void_cast.rs b/tests/unit/out/refcount/void_cast.rs
index 4a070cbc..174a219f 100644
--- a/tests/unit/out/refcount/void_cast.rs
+++ b/tests/unit/out/refcount/void_cast.rs
@@ -22,7 +22,19 @@ impl Clone for NonTrivial {
         this
     }
 }
-impl ByteRepr for NonTrivial {}
+impl ByteRepr for NonTrivial {
+    fn byte_size() -> usize {
+        24
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.data.borrow()).to_bytes(&mut buf[0..24]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            data: Rc::new(RefCell::new(<Vec<i32>>::from_bytes(&buf[0..24]))),
+        }
+    }
+}
 pub fn unused_ref_param_1(x: Ptr<NonTrivial>) {
     (*x.upgrade().deref()).clone();
 }
@@ -50,6 +62,9 @@ impl Clone for Holder {
     }
 }
 impl ByteRepr for Holder {
+    fn byte_size() -> usize {
+        4
+    }
     fn to_bytes(&self, buf: &mut [u8]) {
         (*self.field.borrow()).to_bytes(&mut buf[0..4]);
     }
diff --git a/tests/unit/out/refcount/z_bit_cast.rs b/tests/unit/out/refcount/z_bit_cast.rs
index 45eced5f..a4b0aed5 100644
--- a/tests/unit/out/refcount/z_bit_cast.rs
+++ b/tests/unit/out/refcount/z_bit_cast.rs
@@ -45,7 +45,7 @@ fn main_0() -> i32 {
         _lhs == ((a1.as_pointer() as Ptr<u32>) as Ptr<u32>).to_any()
     });
     assert!({
-        let _lhs = (((*ptr.borrow()).cast::<u32>().expect("ub:wrong type"))
+        let _lhs = (((*ptr.borrow()).reinterpret_cast::<u32>())
             .offset((0) as isize)
             .read());
         _lhs == (*a1.borrow())[(0) as usize]
diff --git a/tests/unit/tag_vs_identifier_collision.c b/tests/unit/tag_vs_identifier_collision.c
index 79212c64..a51731e9 100644
--- a/tests/unit/tag_vs_identifier_collision.c
+++ b/tests/unit/tag_vs_identifier_collision.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 
 typedef enum { MODE_IDLE, MODE_ACTIVE, MODE_DONE } widget;
diff --git a/tests/unit/union_addrof_external.c b/tests/unit/union_addrof_external.c
index 59dc281b..64adaf26 100644
--- a/tests/unit/union_addrof_external.c
+++ b/tests/unit/union_addrof_external.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
diff --git a/tests/unit/union_basic.c b/tests/unit/union_basic.c
index 86731cc2..5d26a336 100644
--- a/tests/unit/union_basic.c
+++ b/tests/unit/union_basic.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 
 union basic {
diff --git a/tests/unit/union_cross_arm_cast.c b/tests/unit/union_cross_arm_cast.c
index 598de31e..f3bf94ac 100644
--- a/tests/unit/union_cross_arm_cast.c
+++ b/tests/unit/union_cross_arm_cast.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
diff --git a/tests/unit/union_field_alignment.c b/tests/unit/union_field_alignment.c
index 63c957d1..0205d532 100644
--- a/tests/unit/union_field_alignment.c
+++ b/tests/unit/union_field_alignment.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
diff --git a/tests/unit/union_flex_array_member.c b/tests/unit/union_flex_array_member.c
index 7a41d456..a166064f 100644
--- a/tests/unit/union_flex_array_member.c
+++ b/tests/unit/union_flex_array_member.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
diff --git a/tests/unit/union_memset_memcpy.c b/tests/unit/union_memset_memcpy.c
index b4a270b6..4b9c7877 100644
--- a/tests/unit/union_memset_memcpy.c
+++ b/tests/unit/union_memset_memcpy.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
diff --git a/tests/unit/union_nested.c b/tests/unit/union_nested.c
index b056725e..7f923854 100644
--- a/tests/unit/union_nested.c
+++ b/tests/unit/union_nested.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stdint.h>
 #include <string.h>
diff --git a/tests/unit/union_pointer_pun_address.c b/tests/unit/union_pointer_pun_address.c
index 421bb1f0..163841d6 100644
--- a/tests/unit/union_pointer_pun_address.c
+++ b/tests/unit/union_pointer_pun_address.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 
 struct node_a {
diff --git a/tests/unit/union_pointer_pun_writethrough.c b/tests/unit/union_pointer_pun_writethrough.c
index d29cbc50..b03d57a0 100644
--- a/tests/unit/union_pointer_pun_writethrough.c
+++ b/tests/unit/union_pointer_pun_writethrough.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 
 int main(void) {
diff --git a/tests/unit/union_struct_dual_use.c b/tests/unit/union_struct_dual_use.c
index 2ddb14f4..a3ee8ba0 100644
--- a/tests/unit/union_struct_dual_use.c
+++ b/tests/unit/union_struct_dual_use.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <string.h>
 
diff --git a/tests/unit/union_tagged_many_arms.c b/tests/unit/union_tagged_many_arms.c
index c492c67d..e3677004 100644
--- a/tests/unit/union_tagged_many_arms.c
+++ b/tests/unit/union_tagged_many_arms.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stdint.h>
 
diff --git a/tests/unit/union_tagged_simple.c b/tests/unit/union_tagged_simple.c
index 590f34bb..6efa44de 100644
--- a/tests/unit/union_tagged_simple.c
+++ b/tests/unit/union_tagged_simple.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 
 typedef enum {
diff --git a/tests/unit/union_tagged_struct_arms.c b/tests/unit/union_tagged_struct_arms.c
index f5b90e18..de0c887f 100644
--- a/tests/unit/union_tagged_struct_arms.c
+++ b/tests/unit/union_tagged_struct_arms.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stdint.h>
 
diff --git a/tests/unit/union_void_ptr_sized_deref.c b/tests/unit/union_void_ptr_sized_deref.c
index 3d957cfe..586a608e 100644
--- a/tests/unit/union_void_ptr_sized_deref.c
+++ b/tests/unit/union_void_ptr_sized_deref.c
@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>