diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index d0863d0c4..05bda04ff 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -1498,12 +1498,8 @@ void Converter::ConvertLoopVariable(clang::VarDecl *decl,
   }
 }
 
-void Converter::ConvertForRangeBody(clang::CXXForRangeStmt *stmt,
-                                    const clang::VarDecl *map_iter_decl) {
+void Converter::ConvertForRangeBody(clang::CXXForRangeStmt *stmt) {
   PushBreakTarget push(break_target_, BreakTarget::Loop);
-  std::optional<ScopedMapIterDecl> skip;
-  if (map_iter_decl)
-    skip.emplace(*this, map_iter_decl);
   curr_for_inc_.emplace_back(nullptr);
   ConvertBodyStmts(stmt->getBody());
   curr_for_inc_.pop_back();
@@ -1529,18 +1525,19 @@ bool Converter::VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) {
 }
 
 bool Converter::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
-  auto *loop_var = stmt->getLoopVariable();
-  auto loop_var_name = GetNamedDeclAsString(loop_var);
+  auto begin =
+      llvm::cast<clang::VarDecl>(stmt->getBeginStmt()->getSingleDecl());
 
   StrCat("'loop_:");
   auto map_type = Mapper::Map(*this, stmt->getRangeInit()->getType());
-  StrCat(keyword::kFor, loop_var_name, keyword::kIn,
+  StrCat(keyword::kFor, GetNamedDeclAsString(begin), keyword::kIn,
          "UnsafeMapIterator::begin(&");
   Convert(stmt->getRangeInit());
   StrCat(std::format(" as *const {})", map_type));
   {
     PushBrace brace(*this);
-    ConvertForRangeBody(stmt, loop_var);
+    Convert(stmt->getLoopVarStmt());
+    ConvertForRangeBody(stmt);
   }
 
   return false;
@@ -3239,8 +3236,7 @@ void Converter::ConvertDeclRefValue(clang::Expr *expr, clang::ValueDecl *decl) {
   auto str = ConvertDeclRef(expr, decl);
   auto type = GetDeclRefType(curr_function_, expr, decl);
 
-  if (type->getAs<clang::ReferenceType>() && !isAddrOf() &&
-      !map_iter_decls_.contains(clang::dyn_cast<clang::VarDecl>(decl))) {
+  if (type->getAs<clang::ReferenceType>() && !isAddrOf()) {
     EmitDeref(std::move(str), type.getNonReferenceType());
     SetValueFreshness(expr->getType());
     return;
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 03dbb1192..7d9e7b75d 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -215,8 +215,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   bool VisitCXXForRangeStmtIndexBased(clang::CXXForRangeStmt *stmt,
                                       const char *len_suffix);
 
-  void ConvertForRangeBody(clang::CXXForRangeStmt *stmt,
-                           const clang::VarDecl *map_iter_decl = nullptr);
+  void ConvertForRangeBody(clang::CXXForRangeStmt *stmt);
 
   virtual bool VisitBreakStmt(clang::BreakStmt *stmt);
 
@@ -902,8 +901,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     Converter &c_;
   };
 
-  std::unordered_set<const clang::VarDecl *> map_iter_decls_;
-
   // Local variables hoisted outside a goto_block so that all labels can see and
   // use the variables.
   std::unordered_set<const clang::VarDecl *> hoisted_decls_;
@@ -954,15 +951,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     operator=(const HoistMaterializedTempBindings &) = delete;
   };
 
-  struct ScopedMapIterDecl {
-    Converter &c;
-    const clang::VarDecl *decl;
-    ScopedMapIterDecl(Converter &c, const clang::VarDecl *decl)
-        : c(c), decl(decl) {
-      c.map_iter_decls_.insert(decl);
-    }
-    ~ScopedMapIterDecl() { c.map_iter_decls_.erase(decl); }
-  };
   static std::unordered_set<std::string> decl_ids_;
   static std::unordered_set<std::string> abstract_structs_;
 
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index 6324cfdb0..8cbacc4eb 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -1902,38 +1902,6 @@ GetStrongestIteratorCategory(clang::ASTContext &ctx, clang::QualType type) {
   return std::nullopt;
 }
 
-const clang::CXXForRangeStmt *
-GetParentForRange(clang::ASTContext &ctx, const clang::MemberExpr *member) {
-  auto base = member->getBase()->IgnoreParenImpCasts();
-  if (auto decl_ref = llvm::dyn_cast<clang::DeclRefExpr>(base)) {
-    if (auto var = llvm::dyn_cast<clang::VarDecl>(decl_ref->getDecl())) {
-      for (const auto &parent : ctx.getParents(*var)) {
-        if (auto decl_stmt = parent.get<clang::DeclStmt>()) {
-          for (const auto &grandparent : ctx.getParents(*decl_stmt)) {
-            if (auto for_range = grandparent.get<clang::CXXForRangeStmt>()) {
-              return for_range;
-            }
-          }
-        }
-      }
-    }
-  }
-  return nullptr;
-}
-
-clang::QualType
-GetForRangeIteratorType(const clang::CXXForRangeStmt *for_range) {
-  if (auto begin_stmt = for_range->getBeginStmt()) {
-    if (auto begin_decl_stmt = llvm::dyn_cast<clang::DeclStmt>(begin_stmt)) {
-      if (auto begin_var = llvm::dyn_cast<clang::VarDecl>(
-              begin_decl_stmt->getSingleDecl())) {
-        return begin_var->getType();
-      }
-    }
-  }
-  return {};
-}
-
 std::string GetClassName(clang::QualType type) {
   if (auto *record = type->getAsCXXRecordDecl())
     return record->getQualifiedNameAsString();
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index 46933b9de..ccbbe8dc3 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -323,12 +323,6 @@ clang::Expr *BuildInitExpr(clang::Sema &sema, clang::QualType type,
                            llvm::ArrayRef<clang::Expr *> args,
                            clang::SourceLocation loc);
 
-const clang::CXXForRangeStmt *
-GetParentForRange(clang::ASTContext &ctx, const clang::MemberExpr *member);
-
-clang::QualType
-GetForRangeIteratorType(const clang::CXXForRangeStmt *for_range);
-
 std::string GetClassName(clang::QualType type);
 
 bool IsVaListType(clang::QualType type);
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 3e21eb964..ca7e40335 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -1044,12 +1044,6 @@ void ConverterRefCount::ConvertDeclRefValue(clang::Expr *expr,
   }
 
   if (auto *ref = decl_t->getAs<clang::ReferenceType>()) {
-    if (map_iter_decls_.contains(clang::dyn_cast<clang::VarDecl>(decl))) {
-      StrCat(str);
-      SetValueFreshness(expr->getType());
-      return;
-    }
-
     if (auto pointee = ref->getPointeeType();
         isObject() && WantsElementPtr() && IsBoxedType(ctx_, pointee)) {
       StrCat(std::format("Ptr::<{}>::decay(&({}))", ToString(pointee),
@@ -2269,19 +2263,19 @@ void ConverterRefCount::EmitByValueShadow(const clang::VarDecl *loop_var,
 }
 
 bool ConverterRefCount::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
-  auto *loop_var = stmt->getLoopVariable();
-  auto loop_var_name = GetNamedDeclAsString(loop_var);
+  auto begin =
+      llvm::cast<clang::VarDecl>(stmt->getBeginStmt()->getSingleDecl());
+  auto begin_name = GetNamedDeclAsString(begin);
 
   StrCat("'loop_:");
-  StrCat(keyword::kFor, loop_var_name, keyword::kIn, "RefcountMapIter::begin(",
+  StrCat(keyword::kFor, begin_name, keyword::kIn, "RefcountMapIter::begin(",
          ConvertObject(stmt->getRangeInit()), ')');
   PushBrace brace(*this);
 
-  EmitByValueShadow(
-      loop_var, std::string(loop_var_name),
-      "Value<" + Mapper::Map(*this, GetForRangeIteratorType(stmt)) + '>');
+  EmitByValueShadow(begin, std::string(begin_name));
+  Convert(stmt->getLoopVarStmt());
 
-  ConvertForRangeBody(stmt, loop_var);
+  ConvertForRangeBody(stmt);
 
   return false;
 }
diff --git a/cpp2rust/converter/printer.cpp b/cpp2rust/converter/printer.cpp
index 1b3f3d037..4a53772a4 100644
--- a/cpp2rust/converter/printer.cpp
+++ b/cpp2rust/converter/printer.cpp
@@ -371,14 +371,6 @@ std::string ToString(clang::ASTContext &ctx, const clang::Expr *expr) {
                    ToString(ctx, member_decl);
           }
         }
-      } else if (auto for_range = GetParentForRange(ctx, ME)) {
-        if (ToString(ctx, for_range->getRangeInit()->getType())
-                .starts_with("std::map<")) {
-          auto iter_type = GetForRangeIteratorType(for_range);
-          if (!iter_type.isNull()) {
-            return ToString(ctx, iter_type) + "->" + ToString(ctx, member_decl);
-          }
-        }
       }
       return ToString(ctx, member_decl);
     }
diff --git a/libcc2rs/src/iterators.rs b/libcc2rs/src/iterators.rs
index acc04b3ce..58fb7a6da 100644
--- a/libcc2rs/src/iterators.rs
+++ b/libcc2rs/src/iterators.rs
@@ -1,11 +1,9 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use crate::{CChar, PostfixDec, PostfixInc, PrefixDec, PrefixInc, Ptr, Value};
-use std::cell::RefCell;
+use crate::{AsPointer, CChar, PostfixDec, PostfixInc, PrefixDec, PrefixInc, Ptr, Value};
 use std::collections::BTreeMap;
 use std::ops::Bound;
-use std::rc::Rc;
 
 pub trait MapAccess: Clone + Default {
     type Key: Ord + Clone;
@@ -45,8 +43,8 @@ pub struct MapIter<K, MapRef> {
     key: Option<K>,
 }
 
-pub type RefcountMapIter<K, V> = MapIter<K, Ptr<BTreeMap<K, Value<V>>>>;
-pub type UnsafeMapIterator<K, V> = MapIter<K, *const BTreeMap<K, Box<V>>>;
+pub type RefcountMapIter<K, V> = MapIter<K, Ptr<BTreeMap<K, Value<(Value<K>, Value<V>)>>>>;
+pub type UnsafeMapIterator<K, V> = MapIter<K, *const BTreeMap<K, Box<(K, V)>>>;
 
 impl<K: Clone, MapRef: Clone> Clone for MapIter<K, MapRef> {
     fn clone(&self) -> Self {
@@ -141,44 +139,31 @@ impl<K: Ord + Clone, MapRef: MapAccess<Key = K>> MapIter<K, MapRef> {
 }
 
 pub trait MapIterator {
-    type First;
-    type Second;
-    fn first(&self) -> Self::First;
-    fn second(&self) -> Self::Second;
+    type Entry;
+    fn deref(&self) -> Self::Entry;
 }
 
 impl<K: Ord + Clone + 'static, V: 'static> MapIterator for RefcountMapIter<K, V> {
-    type First = Value<K>;
-    type Second = Value<V>;
+    type Entry = Ptr<(Value<K>, Value<V>)>;
 
-    fn first(&self) -> Value<K> {
-        let key = self.key.as_ref().expect("ub: dereference of end iterator");
-        Rc::new(RefCell::new(key.clone()))
-    }
-
-    fn second(&self) -> Value<V> {
+    fn deref(&self) -> Ptr<(Value<K>, Value<V>)> {
         let key = self.key.as_ref().expect("ub: dereference of end iterator");
         self.map
-            .with(|m| m.get(key).expect("ub: key not found in map").clone())
+            .with(|m| m.get(key).expect("ub: key not found in map").as_pointer())
     }
 }
 
 impl<K: Ord + Clone, V> MapIterator for UnsafeMapIterator<K, V> {
-    type First = *const K;
-    type Second = *mut V;
-
-    fn first(&self) -> *const K {
-        self.key.as_ref().expect("ub: dereference of end iterator") as *const K
-    }
+    type Entry = *mut (K, V);
 
-    fn second(&self) -> *mut V {
+    fn deref(&self) -> *mut (K, V) {
         unsafe {
-            let map_mut = self.map as *mut BTreeMap<K, Box<V>>;
+            let map_mut = self.map as *mut BTreeMap<K, Box<(K, V)>>;
             let key = self.key.as_ref().expect("ub: dereference of end iterator");
             (*map_mut)
                 .get_mut(key)
                 .expect("ub: key not found in map")
-                .as_mut() as *mut V
+                .as_mut() as *mut (K, V)
         }
     }
 }
diff --git a/rules/map/src.cpp b/rules/map/src.cpp
index 11d535eeb..78e29ddb8 100644
--- a/rules/map/src.cpp
+++ b/rules/map/src.cpp
@@ -134,3 +134,14 @@ template <typename T1, typename T2>
 std::map<T1, T2> &f26(std::map<T1, T2> &dst, const std::map<T1, T2> &src) {
   return dst.operator=(src);
 }
+
+template <typename T1, typename T2>
+std::pair<const T1, T2> &f27(typename std::map<T1, T2>::iterator it) {
+  return it.operator*();
+}
+
+template <typename T1, typename T2>
+const std::pair<const T1, T2> &
+f28(typename std::map<T1, T2>::const_iterator it) {
+  return it.operator*();
+}
diff --git a/rules/map/tgt_refcount.rs b/rules/map/tgt_refcount.rs
index eae9d3d75..8e641ab8e 100644
--- a/rules/map/tgt_refcount.rs
+++ b/rules/map/tgt_refcount.rs
@@ -6,7 +6,7 @@ use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::rc::Rc;
 
-fn t1<T1, T2>() -> BTreeMap<T1, Value<T2>> {
+fn t1<T1, T2>() -> BTreeMap<T1, Value<(Value<T1>, Value<T2>)>> {
     BTreeMap::new()
 }
 
@@ -19,60 +19,88 @@ fn t3<T1: Clone + Ord + 'static, T2: 'static>() -> RefcountMapIter<T1, T2> {
 }
 
 fn f1<T1: Ord + Clone + ByteRepr + 'static, T2: Default + ByteRepr + 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
     a1: T1,
 ) -> Ptr<T2> {
-    a0.with_mut(|__v: &mut BTreeMap<T1, Value<T2>>| {
-        __v.entry(a1)
-            .or_insert_with(|| Rc::new(RefCell::new(<T2>::default())))
+    a0.with_mut(|__v: &mut BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>| {
+        __v.entry(a1.clone())
+            .or_insert_with(|| {
+                Rc::new(RefCell::new((
+                    Rc::new(RefCell::new(a1)),
+                    Rc::new(RefCell::new(<T2>::default())),
+                )))
+            })
+            .borrow()
+            .1
             .as_pointer()
     })
 }
 
-fn f2<T1, T2>(a0: BTreeMap<T1, Value<T2>>) -> usize {
+fn f2<T1, T2>(a0: BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>) -> usize {
     a0.len()
 }
 
 fn f3<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
     a1: RefcountMapIter<T1, T2>,
 ) -> RefcountMapIter<T1, T2> {
     RefcountMapIter::erase(a0, &a1)
 }
 
-fn f5<T1, T2>() -> BTreeMap<T1, Value<T2>> {
+fn f5<T1, T2>() -> BTreeMap<T1, Value<(Value<T1>, Value<T2>)>> {
     BTreeMap::new()
 }
 
-fn f6<T1: Ord + Clone, T2: Clone>(a0: BTreeMap<T1, Value<T2>>) -> BTreeMap<T1, Value<T2>> {
+fn f6<T1: Ord + Clone, T2: Clone>(
+    a0: BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>,
+) -> BTreeMap<T1, Value<(Value<T1>, Value<T2>)>> {
     a0.iter()
-        .map(|(k, v)| (k.clone(), Rc::new(RefCell::new(v.borrow().clone()))))
+        .map(|(k, v)| {
+            let __v = v.borrow();
+            (
+                k.clone(),
+                Rc::new(RefCell::new((
+                    Rc::new(RefCell::new(__v.0.borrow().clone())),
+                    Rc::new(RefCell::new(__v.1.borrow().clone())),
+                ))),
+            )
+        })
         .collect()
 }
 
-fn f7<T1: Ord, T2: Default>(a0: &mut BTreeMap<T1, Value<T2>>, a1: T1) -> Ptr<T2> {
-    a0.get(&a1).expect("out of range!").as_pointer()
+fn f7<T1: Ord, T2: Default>(
+    a0: &mut BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>,
+    a1: T1,
+) -> Ptr<T2> {
+    a0.get(&a1).expect("out of range!").borrow().1.as_pointer()
 }
 
 fn f8<T1: Ord + Clone + ByteRepr + 'static, T2: Default + ByteRepr + 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
     a1: T1,
 ) -> Ptr<T2> {
-    a0.with_mut(|__v: &mut BTreeMap<T1, Value<T2>>| {
-        __v.entry(a1)
-            .or_insert_with(|| Rc::new(RefCell::new(<T2>::default())))
+    a0.with_mut(|__v: &mut BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>| {
+        __v.entry(a1.clone())
+            .or_insert_with(|| {
+                Rc::new(RefCell::new((
+                    Rc::new(RefCell::new(a1)),
+                    Rc::new(RefCell::new(<T2>::default())),
+                )))
+            })
+            .borrow()
+            .1
             .as_pointer()
     })
 }
 
 fn f9<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
 ) -> RefcountMapIter<T1, T2> {
     RefcountMapIter::end(a0)
 }
 
 fn f10<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
     a1: T1,
 ) -> RefcountMapIter<T1, T2> {
     RefcountMapIter::find_key(a0, &a1)
@@ -86,7 +114,7 @@ fn f11<T1: PartialEq, T2: PartialEq>(
 }
 
 fn f12<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
 ) -> RefcountMapIter<T1, T2> {
     RefcountMapIter::begin(a0)
 }
@@ -99,13 +127,16 @@ fn f13<T1: PartialEq, T2: PartialEq>(
 }
 
 fn f14<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
 ) -> RefcountMapIter<T1, T2> {
     RefcountMapIter::end(a0)
 }
 
-fn f15<T1: Ord, T2: Default>(a0: &mut BTreeMap<T1, Value<T2>>, a1: T1) -> Ptr<T2> {
-    a0.get(&a1).expect("out of range!").as_pointer()
+fn f15<T1: Ord, T2: Default>(
+    a0: &mut BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>,
+    a1: T1,
+) -> Ptr<T2> {
+    a0.get(&a1).expect("out of range!").borrow().1.as_pointer()
 }
 
 fn f16<T1: PartialEq, T2: PartialEq>(
@@ -116,7 +147,7 @@ fn f16<T1: PartialEq, T2: PartialEq>(
 }
 
 fn f17<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
     a1: T1,
 ) -> RefcountMapIter<T1, T2> {
     RefcountMapIter::find_key(a0, &a1)
@@ -126,39 +157,71 @@ fn f19<T1: Clone, T2>(a0: RefcountMapIter<T1, T2>) -> RefcountMapIter<T1, T2> {
     a0
 }
 
-fn f20<T1: Ord + Clone + 'static, T2: 'static>(a0: RefcountMapIter<T1, T2>) -> Value<T1> {
-    a0.first()
+fn f20<T1: Ord + Clone + ByteRepr + 'static, T2: ByteRepr + 'static>(
+    a0: RefcountMapIter<T1, T2>,
+) -> Value<T1> {
+    a0.deref().with(|__p| __p.0.clone())
 }
-fn f21<T1: Ord + Clone + 'static, T2: 'static>(a0: RefcountMapIter<T1, T2>) -> Value<T2> {
-    a0.second()
+fn f21<T1: Ord + Clone + ByteRepr + 'static, T2: ByteRepr + 'static>(
+    a0: RefcountMapIter<T1, T2>,
+) -> Value<T2> {
+    a0.deref().with(|__p| __p.1.clone())
 }
 
-fn f22<T1: Ord + Clone + 'static, T2: 'static>(a0: RefcountMapIter<T1, T2>) -> Value<T1> {
-    a0.first()
+fn f22<T1: Ord + Clone + ByteRepr + 'static, T2: ByteRepr + 'static>(
+    a0: RefcountMapIter<T1, T2>,
+) -> Value<T1> {
+    a0.deref().with(|__p| __p.0.clone())
 }
-fn f23<T1: Ord + Clone + 'static, T2: 'static>(a0: RefcountMapIter<T1, T2>) -> Value<T2> {
-    a0.second()
+fn f23<T1: Ord + Clone + ByteRepr + 'static, T2: ByteRepr + 'static>(
+    a0: RefcountMapIter<T1, T2>,
+) -> Value<T2> {
+    a0.deref().with(|__p| __p.1.clone())
 }
 
-fn f24<T1: 'static, T2: 'static>(a0: Ptr<BTreeMap<T1, Value<T2>>>) -> BTreeMap<T1, Value<T2>> {
-    a0.with_mut(|__v: &mut BTreeMap<T1, Value<T2>>| std::mem::take(__v))
+fn f24<T1: 'static, T2: 'static>(
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
+) -> BTreeMap<T1, Value<(Value<T1>, Value<T2>)>> {
+    a0.with_mut(|__v: &mut BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>| std::mem::take(__v))
 }
 
 fn f25<T1: 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
-    a1: Ptr<BTreeMap<T1, Value<T2>>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
+    a1: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
 ) {
-    let __src = a1.with_mut(|__v: &mut BTreeMap<T1, Value<T2>>| std::mem::take(__v));
+    let __src =
+        a1.with_mut(|__v: &mut BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>| std::mem::take(__v));
     a0.write(__src)
 }
 
 fn f26<T1: Ord + Clone + 'static, T2: Clone + 'static>(
-    a0: Ptr<BTreeMap<T1, Value<T2>>>,
-    a1: BTreeMap<T1, Value<T2>>,
+    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
+    a1: BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>,
 ) {
     a0.write(
         a1.iter()
-            .map(|(k, v)| (k.clone(), Rc::new(RefCell::new(v.borrow().clone()))))
+            .map(|(k, v)| {
+                let __v = v.borrow();
+                (
+                    k.clone(),
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(__v.0.borrow().clone())),
+                        Rc::new(RefCell::new(__v.1.borrow().clone())),
+                    ))),
+                )
+            })
             .collect(),
     )
 }
+
+fn f27<T1: Ord + Clone + 'static, T2: 'static>(
+    a0: RefcountMapIter<T1, T2>,
+) -> Ptr<(Value<T1>, Value<T2>)> {
+    a0.deref()
+}
+
+fn f28<T1: Ord + Clone + 'static, T2: 'static>(
+    a0: RefcountMapIter<T1, T2>,
+) -> Ptr<(Value<T1>, Value<T2>)> {
+    a0.deref()
+}
diff --git a/rules/map/tgt_unsafe.rs b/rules/map/tgt_unsafe.rs
index aea54d736..a188f85ed 100644
--- a/rules/map/tgt_unsafe.rs
+++ b/rules/map/tgt_unsafe.rs
@@ -4,7 +4,7 @@
 use libcc2rs::{MapIterator, UnsafeMapIterator};
 use std::collections::BTreeMap;
 
-fn t1<T1, T2>() -> BTreeMap<T1, Box<T2>> {
+fn t1<T1, T2>() -> BTreeMap<T1, Box<(T1, T2)>> {
     BTreeMap::new()
 }
 
@@ -20,41 +20,53 @@ fn t4() -> usize {
     0_usize
 }
 
-unsafe fn f1<T1: Ord + Clone, T2: Default>(a0: &mut BTreeMap<T1, Box<T2>>, a1: T1) -> &mut T2 {
-    a0.entry(a1).or_default().as_mut()
+unsafe fn f1<T1: Ord + Clone, T2: Default>(
+    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
+    a1: T1,
+) -> &mut T2 {
+    &mut a0
+        .entry(a1.clone())
+        .or_insert_with(|| Box::new((a1, <T2>::default())))
+        .1
 }
-unsafe fn f2<T1, T2>(a0: BTreeMap<T1, Box<T2>>) -> usize {
+unsafe fn f2<T1, T2>(a0: BTreeMap<T1, Box<(T1, T2)>>) -> usize {
     a0.len()
 }
 unsafe fn f3<T1: Ord + Clone, T2>(
-    a0: &mut BTreeMap<T1, Box<T2>>,
+    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
     a1: UnsafeMapIterator<T1, T2>,
 ) -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::erase(&*a0 as *const BTreeMap<T1, Box<T2>>, &a1)
+    UnsafeMapIterator::erase(&*a0 as *const BTreeMap<T1, Box<(T1, T2)>>, &a1)
 }
 
-unsafe fn f5<T1, T2>() -> BTreeMap<T1, Box<T2>> {
+unsafe fn f5<T1, T2>() -> BTreeMap<T1, Box<(T1, T2)>> {
     BTreeMap::new()
 }
 
-unsafe fn f6<T1: Clone, T2: Clone>(a0: BTreeMap<T1, Box<T2>>) -> BTreeMap<T1, Box<T2>> {
+unsafe fn f6<T1: Clone, T2: Clone>(a0: BTreeMap<T1, Box<(T1, T2)>>) -> BTreeMap<T1, Box<(T1, T2)>> {
     a0.clone()
 }
-unsafe fn f7<T1: Ord, T2>(a0: &mut BTreeMap<T1, Box<T2>>, a1: T1) -> *const T2 {
-    (a0.get(&a1).expect("out of range!").as_ref() as *const T2)
+unsafe fn f7<T1: Ord, T2>(a0: &mut BTreeMap<T1, Box<(T1, T2)>>, a1: T1) -> *const T2 {
+    (&a0.get(&a1).expect("out of range!").1 as *const T2)
 }
 
-unsafe fn f8<T1: Ord + Clone, T2: Default>(a0: &mut BTreeMap<T1, Box<T2>>, a1: T1) -> &mut T2 {
-    a0.entry(a1).or_default().as_mut()
+unsafe fn f8<T1: Ord + Clone, T2: Default>(
+    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
+    a1: T1,
+) -> &mut T2 {
+    &mut a0
+        .entry(a1.clone())
+        .or_insert_with(|| Box::new((a1, <T2>::default())))
+        .1
 }
-unsafe fn f9<T1: Ord + Clone, T2>(a0: BTreeMap<T1, Box<T2>>) -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::end(&a0 as *const BTreeMap<T1, Box<T2>>)
+unsafe fn f9<T1: Ord + Clone, T2>(a0: BTreeMap<T1, Box<(T1, T2)>>) -> UnsafeMapIterator<T1, T2> {
+    UnsafeMapIterator::end(&a0 as *const BTreeMap<T1, Box<(T1, T2)>>)
 }
 unsafe fn f10<T1: Ord + Clone, T2>(
-    a0: &mut BTreeMap<T1, Box<T2>>,
+    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
     a1: T1,
 ) -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::find_key(&*a0 as *const BTreeMap<T1, Box<T2>>, &a1)
+    UnsafeMapIterator::find_key(&*a0 as *const BTreeMap<T1, Box<(T1, T2)>>, &a1)
 }
 unsafe fn f11<T1: PartialEq, T2: PartialEq>(
     a0: UnsafeMapIterator<T1, T2>,
@@ -62,8 +74,10 @@ unsafe fn f11<T1: PartialEq, T2: PartialEq>(
 ) -> bool {
     a0 != a1
 }
-unsafe fn f12<T1: Ord + Clone, T2>(a0: &mut BTreeMap<T1, Box<T2>>) -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::begin(&*a0 as *const BTreeMap<T1, Box<T2>>)
+unsafe fn f12<T1: Ord + Clone, T2>(
+    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
+) -> UnsafeMapIterator<T1, T2> {
+    UnsafeMapIterator::begin(&*a0 as *const BTreeMap<T1, Box<(T1, T2)>>)
 }
 unsafe fn f13<T1: PartialEq, T2: PartialEq>(
     a0: UnsafeMapIterator<T1, T2>,
@@ -72,11 +86,13 @@ unsafe fn f13<T1: PartialEq, T2: PartialEq>(
     a0 == a1
 }
 
-unsafe fn f14<T1: Ord + Clone, T2>(a0: &mut BTreeMap<T1, Box<T2>>) -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::end(&*a0 as *const BTreeMap<T1, Box<T2>>)
+unsafe fn f14<T1: Ord + Clone, T2>(
+    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
+) -> UnsafeMapIterator<T1, T2> {
+    UnsafeMapIterator::end(&*a0 as *const BTreeMap<T1, Box<(T1, T2)>>)
 }
-unsafe fn f15<T1: Ord, T2>(a0: &mut BTreeMap<T1, Box<T2>>, a1: T1) -> *const T2 {
-    (a0.get(&a1).expect("out of range!").as_ref() as *const T2)
+unsafe fn f15<T1: Ord, T2>(a0: &mut BTreeMap<T1, Box<(T1, T2)>>, a1: T1) -> *const T2 {
+    (&a0.get(&a1).expect("out of range!").1 as *const T2)
 }
 
 unsafe fn f16<T1: PartialEq, T2: PartialEq>(
@@ -85,8 +101,11 @@ unsafe fn f16<T1: PartialEq, T2: PartialEq>(
 ) -> bool {
     a0 == a1
 }
-unsafe fn f17<T1: Ord + Clone, T2>(a0: BTreeMap<T1, Box<T2>>, a1: T1) -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::find_key(&a0 as *const BTreeMap<T1, Box<T2>>, &a1)
+unsafe fn f17<T1: Ord + Clone, T2>(
+    a0: BTreeMap<T1, Box<(T1, T2)>>,
+    a1: T1,
+) -> UnsafeMapIterator<T1, T2> {
+    UnsafeMapIterator::find_key(&a0 as *const BTreeMap<T1, Box<(T1, T2)>>, &a1)
 }
 
 unsafe fn f19<T1: Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> UnsafeMapIterator<T1, T2> {
@@ -94,27 +113,38 @@ unsafe fn f19<T1: Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> UnsafeMapIterator
 }
 
 unsafe fn f20<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *const T1 {
-    a0.first()
+    &raw const (*a0.deref()).0
 }
 unsafe fn f21<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *mut T2 {
-    a0.second()
+    &raw mut (*a0.deref()).1
 }
 
 unsafe fn f22<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *const T1 {
-    a0.first()
+    &raw const (*a0.deref()).0
 }
 unsafe fn f23<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *mut T2 {
-    a0.second()
+    &raw mut (*a0.deref()).1
 }
 
-unsafe fn f24<T1, T2>(a0: &mut BTreeMap<T1, Box<T2>>) -> BTreeMap<T1, Box<T2>> {
+unsafe fn f24<T1, T2>(a0: &mut BTreeMap<T1, Box<(T1, T2)>>) -> BTreeMap<T1, Box<(T1, T2)>> {
     std::mem::take(&mut *a0)
 }
 
-unsafe fn f25<T1, T2>(a0: &mut BTreeMap<T1, Box<T2>>, a1: &mut BTreeMap<T1, Box<T2>>) {
+unsafe fn f25<T1, T2>(a0: &mut BTreeMap<T1, Box<(T1, T2)>>, a1: &mut BTreeMap<T1, Box<(T1, T2)>>) {
     *a0 = std::mem::take(&mut *a1)
 }
 
-unsafe fn f26<T1: Clone, T2: Clone>(a0: &mut BTreeMap<T1, Box<T2>>, a1: BTreeMap<T1, Box<T2>>) {
+unsafe fn f26<T1: Clone, T2: Clone>(
+    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
+    a1: BTreeMap<T1, Box<(T1, T2)>>,
+) {
     *a0 = a1.clone()
 }
+
+unsafe fn f27<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *mut (T1, T2) {
+    a0.deref()
+}
+
+unsafe fn f28<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *const (T1, T2) {
+    a0.deref() as *const (T1, T2)
+}
diff --git a/rules/pair/src.cpp b/rules/pair/src.cpp
index f73a42160..90c0eaddd 100644
--- a/rules/pair/src.cpp
+++ b/rules/pair/src.cpp
@@ -5,6 +5,8 @@
 
 template <typename T1, typename T2> using t1 = std::pair<T1, T2>;
 
+template <typename T1, typename T2> using t2 = std::pair<const T1, T2>;
+
 template <typename T1, typename T2> T2 &f1(std::pair<T1, T2> &o) {
   return o.second;
 }
@@ -63,3 +65,17 @@ template <typename T1, typename T2>
 std::pair<T1, T2> &f14(std::pair<T1, T2> &dst, std::pair<T1, T2> &&src) {
   return dst.operator=(std::move(src));
 }
+
+template <typename T1, typename T2>
+const T1 &f15(std::pair<const T1, T2> &a0) {
+  return a0.first;
+}
+
+template <typename T1, typename T2> T2 &f16(std::pair<const T1, T2> &o) {
+  return o.second;
+}
+
+template <typename T1, typename T2>
+std::pair<const T1, T2> f17(const std::pair<const T1, T2> &a0) {
+  return std::pair<const T1, T2>(a0);
+}
diff --git a/rules/pair/tgt_refcount.rs b/rules/pair/tgt_refcount.rs
index e69c4d842..bbbbf535d 100644
--- a/rules/pair/tgt_refcount.rs
+++ b/rules/pair/tgt_refcount.rs
@@ -12,6 +12,13 @@ fn t1<T1: Default, T2: Default>() -> (Value<T1>, Value<T2>) {
     )
 }
 
+fn t2<T1: Default, T2: Default>() -> (Value<T1>, Value<T2>) {
+    (
+        Rc::new(RefCell::new(T1::default())),
+        Rc::new(RefCell::new(T2::default())),
+    )
+}
+
 fn f1<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Value<T2> {
     a0.1
 }
@@ -89,3 +96,18 @@ fn f14<T1: Default + ByteRepr, T2: Default + ByteRepr>(
 ) {
     a0.write(std::mem::take(&mut *a1))
 }
+
+fn f15<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Value<T1> {
+    a0.0
+}
+
+fn f16<T1, T2>(a0: (Value<T1>, Value<T2>)) -> Value<T2> {
+    a0.1
+}
+
+fn f17<T1: Clone, T2: Clone>(a0: (Value<T1>, Value<T2>)) -> (Value<T1>, Value<T2>) {
+    (
+        Rc::new(RefCell::new(a0.0.borrow().clone())),
+        Rc::new(RefCell::new(a0.1.borrow().clone())),
+    )
+}
diff --git a/rules/pair/tgt_unsafe.rs b/rules/pair/tgt_unsafe.rs
index cfeaa58a5..9312d5835 100644
--- a/rules/pair/tgt_unsafe.rs
+++ b/rules/pair/tgt_unsafe.rs
@@ -5,6 +5,10 @@ fn t1<T1: Default, T2: Default>() -> (T1, T2) {
     <(T1, T2)>::default()
 }
 
+fn t2<T1: Default, T2: Default>() -> (T1, T2) {
+    <(T1, T2)>::default()
+}
+
 unsafe fn f1<T1, T2>(a0: (T1, T2)) -> T2 {
     a0.1
 }
@@ -45,3 +49,15 @@ unsafe fn f13<T1: Clone, T2: Clone>(a0: &mut (T1, T2), a1: (T1, T2)) {
 unsafe fn f14<T1: Default, T2: Default>(a0: &mut (T1, T2), a1: &mut (T1, T2)) {
     *a0 = std::mem::take(&mut *a1)
 }
+
+unsafe fn f15<T1, T2>(a0: (T1, T2)) -> T1 {
+    a0.0
+}
+
+unsafe fn f16<T1, T2>(a0: (T1, T2)) -> T2 {
+    a0.1
+}
+
+unsafe fn f17<T1: Clone, T2: Clone>(a0: (T1, T2)) -> (T1, T2) {
+    a0.clone()
+}
diff --git a/tests/unit/foreach_map.cpp b/tests/unit/foreach_map.cpp
index 6dfaf13cb..857fb8bc4 100644
--- a/tests/unit/foreach_map.cpp
+++ b/tests/unit/foreach_map.cpp
@@ -14,5 +14,12 @@ int main() {
     sum += i.first;
   }
   assert(sum == 7475);
+  for (auto i : m) {
+    i.second = -1;
+    assert(i.second == -1);
+  }
+  for (const auto &i : m) {
+    assert(i.second != -1);
+  }
   return 0;
 }
diff --git a/tests/unit/out/refcount/clone_vs_move.rs b/tests/unit/out/refcount/clone_vs_move.rs
index 5c77efd60..4909dfc3e 100644
--- a/tests/unit/out/refcount/clone_vs_move.rs
+++ b/tests/unit/out/refcount/clone_vs_move.rs
@@ -291,41 +291,72 @@ fn main_0() -> i32 {
         }
         i.prefix_inc();
     }
-    let map1: Value<BTreeMap<i32, Value<i32>>> = Rc::new(RefCell::new(BTreeMap::new()));
+    let map1: Value<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>> =
+        Rc::new(RefCell::new(BTreeMap::new()));
     let mut i: i32 = 0;
     'loop_: while (i < N) {
         let __rhs = i;
-        (map1.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-            .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-                __v.entry(i)
-                    .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+        (map1.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+                __v.entry(i.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(i)),
+                            Rc::new(RefCell::new(<i32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .write(__rhs);
         i.prefix_inc();
     }
-    let map2: Value<BTreeMap<i32, Value<i32>>> = Rc::new(RefCell::new(
+    let map2: Value<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>> = Rc::new(RefCell::new(
         (*map1.borrow())
             .iter()
-            .map(|(k, v)| (k.clone(), Rc::new(RefCell::new(v.borrow().clone()))))
+            .map(|(k, v)| {
+                let __v = v.borrow();
+                (
+                    k.clone(),
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(__v.0.borrow().clone())),
+                        Rc::new(RefCell::new(__v.1.borrow().clone())),
+                    ))),
+                )
+            })
             .collect(),
     ));
     let mut i: i32 = 0;
     'loop_: while (i < N) {
         assert!(
-            (((map2.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-                .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-                    __v.entry(i)
-                        .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+            (((map2.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+                .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+                    __v.entry(i.clone())
+                        .or_insert_with(|| {
+                            Rc::new(RefCell::new((
+                                Rc::new(RefCell::new(i)),
+                                Rc::new(RefCell::new(<i32>::default())),
+                            )))
+                        })
+                        .borrow()
+                        .1
                         .as_pointer()
                 })
                 .read())
                 == i)
         );
-        (map2.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-            .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-                __v.entry(i)
-                    .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+        (map2.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+                __v.entry(i.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(i)),
+                            Rc::new(RefCell::new(<i32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .with_mut(|__v| __v.prefix_inc());
@@ -334,20 +365,34 @@ fn main_0() -> i32 {
     let mut i: i32 = 0;
     'loop_: while (i < N) {
         assert!(
-            (((map1.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-                .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-                    __v.entry(i)
-                        .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+            (((map1.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+                .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+                    __v.entry(i.clone())
+                        .or_insert_with(|| {
+                            Rc::new(RefCell::new((
+                                Rc::new(RefCell::new(i)),
+                                Rc::new(RefCell::new(<i32>::default())),
+                            )))
+                        })
+                        .borrow()
+                        .1
                         .as_pointer()
                 })
                 .read())
                 == i)
         );
         assert!(
-            (((map2.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-                .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-                    __v.entry(i)
-                        .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+            (((map2.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+                .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+                    __v.entry(i.clone())
+                        .or_insert_with(|| {
+                            Rc::new(RefCell::new((
+                                Rc::new(RefCell::new(i)),
+                                Rc::new(RefCell::new(<i32>::default())),
+                            )))
+                        })
+                        .borrow()
+                        .1
                         .as_pointer()
                 })
                 .read())
diff --git a/tests/unit/out/refcount/find.rs b/tests/unit/out/refcount/find.rs
index 86c948ba8..7c24ef54c 100644
--- a/tests/unit/out/refcount/find.rs
+++ b/tests/unit/out/refcount/find.rs
@@ -38,33 +38,55 @@ fn main_0() -> i32 {
         )
     }));
     let mut v_result_true: bool = (*it.borrow()) != (v.as_pointer() as Ptr<i32>).to_end();
-    let m: Value<BTreeMap<i32, Value<f64>>> = Rc::new(RefCell::new(BTreeMap::new()));
-    (m.as_pointer() as Ptr<BTreeMap<i32, Value<f64>>>)
-        .with_mut(|__v: &mut BTreeMap<i32, Value<f64>>| {
-            __v.entry(1)
-                .or_insert_with(|| Rc::new(RefCell::new(<f64>::default())))
+    let m: Value<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>> =
+        Rc::new(RefCell::new(BTreeMap::new()));
+    (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>| {
+            __v.entry(1.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(1)),
+                        Rc::new(RefCell::new(<f64>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(1_f64);
-    (m.as_pointer() as Ptr<BTreeMap<i32, Value<f64>>>)
-        .with_mut(|__v: &mut BTreeMap<i32, Value<f64>>| {
-            __v.entry(2)
-                .or_insert_with(|| Rc::new(RefCell::new(<f64>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>| {
+            __v.entry(2.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(2)),
+                        Rc::new(RefCell::new(<f64>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(2_f64);
-    (m.as_pointer() as Ptr<BTreeMap<i32, Value<f64>>>)
-        .with_mut(|__v: &mut BTreeMap<i32, Value<f64>>| {
-            __v.entry(3)
-                .or_insert_with(|| Rc::new(RefCell::new(<f64>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>| {
+            __v.entry(3.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(3)),
+                        Rc::new(RefCell::new(<f64>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(3_f64);
     let m_begin: Value<RefcountMapIter<i32, f64>> = Rc::new(RefCell::new(RefcountMapIter::begin(
-        (m.as_pointer() as Ptr<BTreeMap<i32, Value<f64>>>),
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>>),
     )));
     let m_end: Value<RefcountMapIter<i32, f64>> = Rc::new(RefCell::new(RefcountMapIter::end(
-        (m.as_pointer() as Ptr<BTreeMap<i32, Value<f64>>>),
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>>),
     )));
     let mut m_result_true: bool = (*m_begin.borrow()) != (*m_end.borrow());
     assert!(
diff --git a/tests/unit/out/refcount/foreach_map.rs b/tests/unit/out/refcount/foreach_map.rs
index a6537da94..330c91602 100644
--- a/tests/unit/out/refcount/foreach_map.rs
+++ b/tests/unit/out/refcount/foreach_map.rs
@@ -11,14 +11,22 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let m: Value<BTreeMap<i32, Value<f64>>> = Rc::new(RefCell::new(BTreeMap::new()));
+    let m: Value<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>> =
+        Rc::new(RefCell::new(BTreeMap::new()));
     let mut i: i32 = 0;
     let mut k: i32 = 100;
     'loop_: while (i < 100) {
-        (m.as_pointer() as Ptr<BTreeMap<i32, Value<f64>>>)
-            .with_mut(|__v: &mut BTreeMap<i32, Value<f64>>| {
-                __v.entry(i)
-                    .or_insert_with(|| Rc::new(RefCell::new(<f64>::default())))
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>| {
+                __v.entry(i.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(i)),
+                            Rc::new(RefCell::new(<f64>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .write(((k as f64) / 2_f64));
@@ -28,14 +36,54 @@ fn main_0() -> i32 {
         };
     }
     let mut sum: f64 = 0_f64;
-    'loop_: for i in RefcountMapIter::begin(m.as_pointer()) {
-        sum += (*i.second().borrow());
+    'loop_: for __begin1 in RefcountMapIter::begin(m.as_pointer()) {
+        let __begin1: Value<RefcountMapIter<i32, f64>> = Rc::new(RefCell::new(__begin1));
+        let i: Ptr<(Value<i32>, Value<f64>)> = (*__begin1.borrow()).deref();
+        sum += (*(*i.upgrade().deref()).1.borrow());
     }
-    'loop_: for i in RefcountMapIter::begin(m.as_pointer()) {
-        let i: Value<RefcountMapIter<i32, f64>> = Rc::new(RefCell::new(i));
-        sum += ((*(*i.borrow()).first().borrow()) as f64);
+    'loop_: for __begin1 in RefcountMapIter::begin(m.as_pointer()) {
+        let __begin1: Value<RefcountMapIter<i32, f64>> = Rc::new(RefCell::new(__begin1));
+        let i: Value<(Value<i32>, Value<f64>)> = Rc::new(RefCell::new((
+            Rc::new(RefCell::new(
+                (*(*__begin1.borrow()).deref().upgrade().deref())
+                    .0
+                    .borrow()
+                    .clone(),
+            )),
+            Rc::new(RefCell::new(
+                (*(*__begin1.borrow()).deref().upgrade().deref())
+                    .1
+                    .borrow()
+                    .clone(),
+            )),
+        )));
+        sum += ((*(*i.borrow()).0.borrow()) as f64);
     }
     assert!((sum == 7475_f64));
+    'loop_: for __begin1 in RefcountMapIter::begin(m.as_pointer()) {
+        let __begin1: Value<RefcountMapIter<i32, f64>> = Rc::new(RefCell::new(__begin1));
+        let i: Value<(Value<i32>, Value<f64>)> = Rc::new(RefCell::new((
+            Rc::new(RefCell::new(
+                (*(*__begin1.borrow()).deref().upgrade().deref())
+                    .0
+                    .borrow()
+                    .clone(),
+            )),
+            Rc::new(RefCell::new(
+                (*(*__begin1.borrow()).deref().upgrade().deref())
+                    .1
+                    .borrow()
+                    .clone(),
+            )),
+        )));
+        (*(*i.borrow()).1.borrow_mut()) = (-1_i32 as f64);
+        assert!(((*(*i.borrow()).1.borrow()) == (-1_i32 as f64)));
+    }
+    'loop_: for __begin1 in RefcountMapIter::begin(m.as_pointer()) {
+        let __begin1: Value<RefcountMapIter<i32, f64>> = Rc::new(RefCell::new(__begin1));
+        let i: Ptr<(Value<i32>, Value<f64>)> = (*__begin1.borrow()).deref();
+        assert!(((*(*i.upgrade().deref()).1.borrow()) != (-1_i32 as f64)));
+    }
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/map-reallocation.rs b/tests/unit/out/refcount/map-reallocation.rs
index 3337e11ac..53c22cf71 100644
--- a/tests/unit/out/refcount/map-reallocation.rs
+++ b/tests/unit/out/refcount/map-reallocation.rs
@@ -13,22 +13,33 @@ pub fn main() {
 fn main_0() -> i32 {
     let mut N: i32 = 10000;
     let mut sentinel: i32 = (N / 2);
-    let m: Value<BTreeMap<i32, Value<i32>>> = Rc::new(RefCell::new(BTreeMap::new()));
+    let m: Value<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>> =
+        Rc::new(RefCell::new(BTreeMap::new()));
     let __rhs = sentinel;
-    (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-        .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-            __v.entry(sentinel)
-                .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+            __v.entry(sentinel.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(sentinel)),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(__rhs);
     let it: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(RefcountMapIter::find_key(
-        (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>),
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>),
         &sentinel,
     )));
-    let mut p: Ptr<i32> = ((*it.borrow()).second().as_pointer());
+    let mut p: Ptr<i32> = ((*it.borrow())
+        .deref()
+        .with(|__p| __p.1.clone())
+        .as_pointer());
     assert!(
-        ((*(*it.borrow()).second().borrow()) == sentinel)
+        ((*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow()) == sentinel)
             && (!(Ptr::<i8>::from_string_literal(
                 b"iterator does not have correct value before insert"
             ))
@@ -44,10 +55,17 @@ fn main_0() -> i32 {
     let mut i: i32 = 0;
     'loop_: while (i < sentinel) {
         let __rhs = i;
-        (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-            .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-                __v.entry(i)
-                    .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+                __v.entry(i.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(i)),
+                            Rc::new(RefCell::new(<i32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .write(__rhs);
@@ -56,24 +74,31 @@ fn main_0() -> i32 {
     let mut i: i32 = (sentinel + 1);
     'loop_: while (i <= N) {
         let __rhs = i;
-        (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-            .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-                __v.entry(i)
-                    .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+                __v.entry(i.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(i)),
+                            Rc::new(RefCell::new(<i32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .write(__rhs);
         i.prefix_inc();
     }
     assert!(
-        ((*(*it.borrow()).second().borrow()) != 0)
+        ((*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow()) != 0)
             && (!(Ptr::<i8>::from_string_literal(
                 b"in refcount, iterator points to index 0 instead of sentinel"
             ))
             .is_null())
     );
     assert!(
-        ((*(*it.borrow()).second().borrow()) == sentinel)
+        ((*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow()) == sentinel)
             && (!(Ptr::<i8>::from_string_literal(
                 b"iterator does not have correct value after insert"
             ))
@@ -86,12 +111,22 @@ fn main_0() -> i32 {
             ))
             .is_null())
     );
-    (*(*it.borrow()).second().borrow_mut()) = 57005;
+    (*(*it.borrow())
+        .deref()
+        .with(|__p| __p.1.clone())
+        .borrow_mut()) = 57005;
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-            .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-                __v.entry(sentinel)
-                    .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+                __v.entry(sentinel.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(sentinel)),
+                            Rc::new(RefCell::new(<i32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
@@ -100,9 +135,11 @@ fn main_0() -> i32 {
     assert!(((p.read()) == 57005));
     assert!(((*m.borrow()).len() == (((N + 1) as u32) as usize)));
     let mut prev: i32 = -1_i32;
-    'loop_: for pair in RefcountMapIter::begin(m.as_pointer()) {
-        assert!(({ (*pair.first().borrow()) } > { prev }));
-        prev = (*pair.first().borrow());
+    'loop_: for __begin1 in RefcountMapIter::begin(m.as_pointer()) {
+        let __begin1: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(__begin1));
+        let pair: Ptr<(Value<i32>, Value<i32>)> = (*__begin1.borrow()).deref();
+        assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { prev }));
+        prev = (*(*pair.upgrade().deref()).0.borrow());
     }
     return 0;
 }
diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs
index feac3e05e..df784caa8 100644
--- a/tests/unit/out/refcount/map.rs
+++ b/tests/unit/out/refcount/map.rs
@@ -17,93 +17,164 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let m: Value<BTreeMap<i16, Value<u32>>> = Rc::new(RefCell::new(BTreeMap::new()));
-    (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-        .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-            __v.entry(0_i16)
-                .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+    let m: Value<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>> =
+        Rc::new(RefCell::new(BTreeMap::new()));
+    (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+            __v.entry(0_i16.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(0_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(1_u32);
-    (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-        .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-            __v.entry(1_i16)
-                .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+            __v.entry(1_i16.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(1_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(2_u32);
-    (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-        .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-            __v.entry(2_i16)
-                .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+            __v.entry(2_i16.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(2_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(3_u32);
     assert!(((*m.borrow()).len() == 3_usize));
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(0_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(0_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(0_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 1_u32)
     );
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(1_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(1_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(1_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 2_u32)
     );
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(2_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(2_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(2_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 3_u32)
     );
     let mut x: i32 = 4;
-    (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-        .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-            __v.entry(1_i16)
-                .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+            __v.entry(1_i16.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(1_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write((x as u32));
     assert!(((*m.borrow()).len() == 3_usize));
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(0_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(0_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(0_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 1_u32)
     );
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(1_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(1_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(1_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 4_u32)
     );
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(2_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(2_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(2_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
@@ -111,200 +182,355 @@ fn main_0() -> i32 {
     );
     ({
         foo_0(
-            ((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-                .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                    __v.entry(0_i16)
-                        .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+            ((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+                .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                    __v.entry(0_i16.clone())
+                        .or_insert_with(|| {
+                            Rc::new(RefCell::new((
+                                Rc::new(RefCell::new(0_i16)),
+                                Rc::new(RefCell::new(<u32>::default())),
+                            )))
+                        })
+                        .borrow()
+                        .1
                         .as_pointer()
                 })
                 .read()),
         )
     });
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(0_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(0_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(0_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 1_u32)
     );
     ({
-        bar_1((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>).with_mut(
-            |__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(2_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
-                    .as_pointer()
-            },
-        ))
+        bar_1(
+            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>).with_mut(
+                |__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                    __v.entry(2_i16.clone())
+                        .or_insert_with(|| {
+                            Rc::new(RefCell::new((
+                                Rc::new(RefCell::new(2_i16)),
+                                Rc::new(RefCell::new(<u32>::default())),
+                            )))
+                        })
+                        .borrow()
+                        .1
+                        .as_pointer()
+                },
+            ),
+        )
     });
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(2_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(2_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(2_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 4_u32)
     );
-    let __rhs = ((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-        .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-            __v.entry(0_i16)
-                .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+    let __rhs = ((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+            __v.entry(0_i16.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(0_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .read())
     .wrapping_add(
-        ((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(2_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        ((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(2_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(2_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read()),
     );
-    (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-        .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-            __v.entry(0_i16)
-                .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+            __v.entry(0_i16.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(0_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(__rhs);
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(0_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(0_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(0_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 5_u32)
     );
     let end: Value<RefcountMapIter<i16, u32>> = Rc::new(RefCell::new(RefcountMapIter::end(
-        (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>),
+        (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
     )));
     let it: Value<RefcountMapIter<i16, u32>> = Rc::new(RefCell::new(RefcountMapIter::find_key(
-        (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>),
+        (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
         &1_i16,
     )));
-    let const_it: Value<RefcountMapIter<i16, u32>> = Rc::new(RefCell::new(
-        RefcountMapIter::find_key((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>), &10_i16),
-    ));
+    let const_it: Value<RefcountMapIter<i16, u32>> =
+        Rc::new(RefCell::new(RefcountMapIter::find_key(
+            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
+            &10_i16,
+        )));
     let mut x1: u32 = if (*it.borrow()) == (*end.borrow()) {
         0_u32
     } else {
-        (*(*it.borrow()).second().borrow())
+        (*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow())
     };
     assert!((x1 == 4_u32));
     let mut x2: u32 = if (*const_it.borrow()) == (*end.borrow()) {
         0_u32
     } else {
-        (*(*const_it.borrow()).second().borrow())
+        (*(*const_it.borrow())
+            .deref()
+            .with(|__p| __p.1.clone())
+            .borrow())
     };
     assert!((x2 == 0_u32));
     let mut x3: u32 = if (*it.borrow())
-        == RefcountMapIter::end((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>))
-    {
+        == RefcountMapIter::end(
+            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
+        ) {
         0_u32
     } else {
-        (*(*it.borrow()).second().borrow())
+        (*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow())
     };
     assert!((x3 == 4_u32));
     let mut x4: u32 = if (*const_it.borrow())
-        == RefcountMapIter::end((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>))
-    {
+        == RefcountMapIter::end(
+            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
+        ) {
         0_u32
     } else {
-        (*(*const_it.borrow()).second().borrow())
+        (*(*const_it.borrow())
+            .deref()
+            .with(|__p| __p.1.clone())
+            .borrow())
     };
     assert!((x4 == 0_u32));
-    (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-        .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-            __v.entry(4_i16)
-                .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+            __v.entry(4_i16.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(4_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(5_u32);
     let it4: Value<RefcountMapIter<i16, u32>> = Rc::new(RefCell::new(RefcountMapIter::find_key(
-        (m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>),
+        (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
         &4_i16,
     )));
-    let mut p: Ptr<u32> = ((*it4.borrow()).second().as_pointer());
+    let mut p: Ptr<u32> = ((*it4.borrow())
+        .deref()
+        .with(|__p| __p.1.clone())
+        .as_pointer());
     let mut x5: u32 = (p.read());
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(4_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(4_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(4_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 5_u32)
     );
-    assert!(((*(*it4.borrow()).second().borrow()) == 5_u32));
+    assert!(((*(*it4.borrow()).deref().with(|__p| __p.1.clone()).borrow()) == 5_u32));
     assert!(((p.read()) == 5_u32));
     assert!((x5 == 5_u32));
     p.with_mut(|__v| __v.prefix_inc());
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>)
-            .with_mut(|__v: &mut BTreeMap<i16, Value<u32>>| {
-                __v.entry(4_i16)
-                    .or_insert_with(|| Rc::new(RefCell::new(<u32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>| {
+                __v.entry(4_i16.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(4_i16)),
+                            Rc::new(RefCell::new(<u32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
             == 6_u32)
     );
-    assert!(((*(*it4.borrow()).second().borrow()) == 6_u32));
+    assert!(((*(*it4.borrow()).deref().with(|__p| __p.1.clone()).borrow()) == 6_u32));
     assert!(((p.read()) == 6_u32));
     assert!((x5 == 5_u32));
-    let r: Ptr<BTreeMap<i16, Value<u32>>> = m.as_pointer();
+    let r: Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>> = m.as_pointer();
     assert!(((*r.upgrade().deref()).len() == 4_usize));
     assert!(
-        RefcountMapIter::find_key((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>), &4_i16)
-            != RefcountMapIter::end((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>))
+        RefcountMapIter::find_key(
+            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
+            &4_i16
+        ) != RefcountMapIter::end(
+            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        )
     );
     RefcountMapIter::erase(
-        ((r).clone() as Ptr<BTreeMap<i16, Value<u32>>>),
+        ((r).clone() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
         &(*it4.borrow()).clone(),
     );
     assert!(((*r.upgrade().deref()).len() == 3_usize));
     assert!(
-        RefcountMapIter::find_key((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>), &4_i16)
-            == RefcountMapIter::end((m.as_pointer() as Ptr<BTreeMap<i16, Value<u32>>>))
+        RefcountMapIter::find_key(
+            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
+            &4_i16
+        ) == RefcountMapIter::end(
+            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
+        )
     );
-    let other_map: Value<BTreeMap<(Value<i32>, Value<i64>), Value<f64>>> =
-        Rc::new(RefCell::new(BTreeMap::new()));
+    let other_map: Value<
+        BTreeMap<(Value<i32>, Value<i64>), Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>>,
+    > = Rc::new(RefCell::new(BTreeMap::new()));
     assert!(((*other_map.borrow()).len() == 0_usize));
     let key0: Value<(Value<i32>, Value<i64>)> = Rc::new(RefCell::new((
         Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
         Rc::new(RefCell::new(1.try_into().expect("failed conversion"))),
     )));
     let mut value: f64 = 2_f64;
-    (other_map.as_pointer() as Ptr<BTreeMap<(Value<i32>, Value<i64>), Value<f64>>>)
-        .with_mut(|__v: &mut BTreeMap<(Value<i32>, Value<i64>), Value<f64>>| {
-            __v.entry((*key0.borrow()).clone())
-                .or_insert_with(|| Rc::new(RefCell::new(<f64>::default())))
-                .as_pointer()
-        })
+    (other_map.as_pointer()
+        as Ptr<
+            BTreeMap<
+                (Value<i32>, Value<i64>),
+                Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+            >,
+        >)
+        .with_mut(
+            |__v: &mut BTreeMap<
+                (Value<i32>, Value<i64>),
+                Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+            >| {
+                __v.entry((*key0.borrow()).clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new((*key0.borrow()).clone())),
+                            Rc::new(RefCell::new(<f64>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
+                    .as_pointer()
+            },
+        )
         .write(value);
-    value = ((other_map.as_pointer() as Ptr<BTreeMap<(Value<i32>, Value<i64>), Value<f64>>>)
-        .with_mut(|__v: &mut BTreeMap<(Value<i32>, Value<i64>), Value<f64>>| {
-            __v.entry((*key0.borrow()).clone())
-                .or_insert_with(|| Rc::new(RefCell::new(<f64>::default())))
-                .as_pointer()
-        })
+    value = ((other_map.as_pointer()
+        as Ptr<
+            BTreeMap<
+                (Value<i32>, Value<i64>),
+                Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+            >,
+        >)
+        .with_mut(
+            |__v: &mut BTreeMap<
+                (Value<i32>, Value<i64>),
+                Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+            >| {
+                __v.entry((*key0.borrow()).clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new((*key0.borrow()).clone())),
+                            Rc::new(RefCell::new(<f64>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
+                    .as_pointer()
+            },
+        )
         .read());
     assert!(((*other_map.borrow()).len() == 1_usize));
     assert!(
-        (((other_map.as_pointer() as Ptr<BTreeMap<(Value<i32>, Value<i64>), Value<f64>>>)
-            .with_mut(|__v: &mut BTreeMap<(Value<i32>, Value<i64>), Value<f64>>| {
-                __v.entry((*key0.borrow()).clone())
-                    .or_insert_with(|| Rc::new(RefCell::new(<f64>::default())))
-                    .as_pointer()
-            })
+        (((other_map.as_pointer()
+            as Ptr<
+                BTreeMap<
+                    (Value<i32>, Value<i64>),
+                    Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+                >,
+            >)
+            .with_mut(
+                |__v: &mut BTreeMap<
+                    (Value<i32>, Value<i64>),
+                    Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+                >| {
+                    __v.entry((*key0.borrow()).clone())
+                        .or_insert_with(|| {
+                            Rc::new(RefCell::new((
+                                Rc::new(RefCell::new((*key0.borrow()).clone())),
+                                Rc::new(RefCell::new(<f64>::default())),
+                            )))
+                        })
+                        .borrow()
+                        .1
+                        .as_pointer()
+                }
+            )
             .read())
             == value)
     );
@@ -314,6 +540,8 @@ fn main_0() -> i32 {
         (((*m.borrow())
             .get(&(k as i16))
             .expect("out of range!")
+            .borrow()
+            .1
             .as_pointer()
             .read())
             == 5_u32)
@@ -323,6 +551,8 @@ fn main_0() -> i32 {
         (((*m.borrow())
             .get(&(k as i16))
             .expect("out of range!")
+            .borrow()
+            .1
             .as_pointer()
             .read())
             == 4_u32)
@@ -332,11 +562,14 @@ fn main_0() -> i32 {
         (((*m.borrow())
             .get(&(k as i16))
             .expect("out of range!")
+            .borrow()
+            .1
             .as_pointer()
             .read())
             == 4_u32)
     );
-    let m2: Value<BTreeMap<i32, Value<bool>>> = Rc::new(RefCell::new(BTreeMap::new()));
+    let m2: Value<BTreeMap<i32, Value<(Value<i32>, Value<bool>)>>> =
+        Rc::new(RefCell::new(BTreeMap::new()));
     assert!(((*m2.borrow()).len() == 0_usize));
     let mut indexes: Vec<i32> = Vec::new();
     let mut i: u32 = 60_u32;
@@ -366,26 +599,43 @@ fn main_0() -> i32 {
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < indexes.len()) {
         let __rhs = ((i).wrapping_rem(2_u32) != 0);
-        (m2.as_pointer() as Ptr<BTreeMap<i32, Value<bool>>>)
-            .with_mut(|__v: &mut BTreeMap<i32, Value<bool>>| {
-                __v.entry(indexes[(i as usize)])
-                    .or_insert_with(|| Rc::new(RefCell::new(<bool>::default())))
-                    .as_pointer()
-            })
+        (m2.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<bool>)>>>)
+            .with_mut(
+                |__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<bool>)>>| {
+                    __v.entry(indexes[(i as usize)].clone())
+                        .or_insert_with(|| {
+                            Rc::new(RefCell::new((
+                                Rc::new(RefCell::new(indexes[(i as usize)])),
+                                Rc::new(RefCell::new(<bool>::default())),
+                            )))
+                        })
+                        .borrow()
+                        .1
+                        .as_pointer()
+                },
+            )
             .write(__rhs);
         i.prefix_inc();
     }
     assert!(((*m2.borrow()).len() == indexes.len()));
     let mut last: i32 = -1_i32;
-    'loop_: for pair in RefcountMapIter::begin(m2.as_pointer()) {
-        assert!(({ (*pair.first().borrow()) } > { last }));
-        assert!(({ ((*pair.second().borrow()) as i32) } == { ((*pair.first().borrow()) % 2) }));
-        last = (*pair.first().borrow());
+    'loop_: for __begin1 in RefcountMapIter::begin(m2.as_pointer()) {
+        let __begin1: Value<RefcountMapIter<i32, bool>> = Rc::new(RefCell::new(__begin1));
+        let pair: Ptr<(Value<i32>, Value<bool>)> = (*__begin1.borrow()).deref();
+        assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { last }));
+        assert!(
+            ({ ((*(*pair.upgrade().deref()).1.borrow()) as i32) } == {
+                ((*(*pair.upgrade().deref()).0.borrow()) % 2)
+            })
+        );
+        last = (*(*pair.upgrade().deref()).0.borrow());
     }
     k = 0;
     let value_0: Ptr<u32> = (*m.borrow())
         .get(&(k as i16))
         .expect("out of range!")
+        .borrow()
+        .1
         .as_pointer();
     assert!(
         ((((((((*m.borrow()).len()).wrapping_add((x1 as usize))).wrapping_add((x2 as usize)))
diff --git a/tests/unit/out/refcount/operator_traits.rs b/tests/unit/out/refcount/operator_traits.rs
index d26ee9550..f6a328f26 100644
--- a/tests/unit/out/refcount/operator_traits.rs
+++ b/tests/unit/out/refcount/operator_traits.rs
@@ -248,32 +248,57 @@ fn main_0() -> i32 {
             .v
         } == 2)
     );
-    let m: Value<BTreeMap<Lt, Value<i32>>> = Rc::new(RefCell::new(BTreeMap::new()));
-    (m.as_pointer() as Ptr<BTreeMap<Lt, Value<i32>>>)
-        .with_mut(|__v: &mut BTreeMap<Lt, Value<i32>>| {
-            __v.entry(Lt { v: 2 })
-                .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+    let m: Value<BTreeMap<Lt, Value<(Value<Lt>, Value<i32>)>>> =
+        Rc::new(RefCell::new(BTreeMap::new()));
+    (m.as_pointer() as Ptr<BTreeMap<Lt, Value<(Value<Lt>, Value<i32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<Lt, Value<(Value<Lt>, Value<i32>)>>| {
+            __v.entry(Lt { v: 2 }.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(Lt { v: 2 })),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(20);
-    (m.as_pointer() as Ptr<BTreeMap<Lt, Value<i32>>>)
-        .with_mut(|__v: &mut BTreeMap<Lt, Value<i32>>| {
-            __v.entry(Lt { v: 1 })
-                .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+    (m.as_pointer() as Ptr<BTreeMap<Lt, Value<(Value<Lt>, Value<i32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<Lt, Value<(Value<Lt>, Value<i32>)>>| {
+            __v.entry(Lt { v: 1 }.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(Lt { v: 1 })),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(10);
     assert!(
-        ((*RefcountMapIter::begin((m.as_pointer() as Ptr<BTreeMap<Lt, Value<i32>>>))
-            .second()
-            .borrow())
+        ((*RefcountMapIter::begin(
+            (m.as_pointer() as Ptr<BTreeMap<Lt, Value<(Value<Lt>, Value<i32>)>>>)
+        )
+        .deref()
+        .with(|__p| __p.1.clone())
+        .borrow())
             == 10)
     );
     assert!(
-        (((m.as_pointer() as Ptr<BTreeMap<Lt, Value<i32>>>)
-            .with_mut(|__v: &mut BTreeMap<Lt, Value<i32>>| {
-                __v.entry(Lt { v: 2 })
-                    .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+        (((m.as_pointer() as Ptr<BTreeMap<Lt, Value<(Value<Lt>, Value<i32>)>>>)
+            .with_mut(|__v: &mut BTreeMap<Lt, Value<(Value<Lt>, Value<i32>)>>| {
+                __v.entry(Lt { v: 2 }.clone())
+                    .or_insert_with(|| {
+                        Rc::new(RefCell::new((
+                            Rc::new(RefCell::new(Lt { v: 2 })),
+                            Rc::new(RefCell::new(<i32>::default())),
+                        )))
+                    })
+                    .borrow()
+                    .1
                     .as_pointer()
             })
             .read())
diff --git a/tests/unit/out/refcount/redundant_copy_in_conversion.rs b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
index b50b80e11..b1420ce0e 100644
--- a/tests/unit/out/refcount/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
@@ -10,7 +10,7 @@ pub fn sink_0(it: RefcountMapIter<i32, i32>) -> i32 {
     let it: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(it));
     let cit: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new((*it.borrow()).clone()));
     return if (*cit.borrow()) == (*it.borrow()) {
-        (*(*it.borrow()).second().borrow())
+        (*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow())
     } else {
         0
     };
@@ -20,19 +20,27 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let m: Value<BTreeMap<i32, Value<i32>>> = Rc::new(RefCell::new(BTreeMap::new()));
-    (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>)
-        .with_mut(|__v: &mut BTreeMap<i32, Value<i32>>| {
-            __v.entry(0)
-                .or_insert_with(|| Rc::new(RefCell::new(<i32>::default())))
+    let m: Value<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>> =
+        Rc::new(RefCell::new(BTreeMap::new()));
+    (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>)
+        .with_mut(|__v: &mut BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>| {
+            __v.entry(0.clone())
+                .or_insert_with(|| {
+                    Rc::new(RefCell::new((
+                        Rc::new(RefCell::new(0)),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )))
+                })
+                .borrow()
+                .1
                 .as_pointer()
         })
         .write(1);
     let end: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(RefcountMapIter::end(
-        (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>),
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>),
     )));
     let it0: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new(RefcountMapIter::find_key(
-        (m.as_pointer() as Ptr<BTreeMap<i32, Value<i32>>>),
+        (m.as_pointer() as Ptr<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>>),
         &0,
     )));
     let const_it: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new((*it0.borrow()).clone()));
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
index bcbd79652..7398992ff 100644
--- a/tests/unit/out/unsafe/clone_vs_move.rs
+++ b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -165,23 +165,48 @@ unsafe fn main_0() -> i32 {
         }
         i.prefix_inc();
     }
-    let mut map1: BTreeMap<i32, Box<i32>> = BTreeMap::new();
+    let mut map1: BTreeMap<i32, Box<(i32, i32)>> = BTreeMap::new();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        (*map1.entry(i).or_default().as_mut()) = i;
+        (*&mut map1
+            .entry(i.clone())
+            .or_insert_with(|| Box::new((i, <i32>::default())))
+            .1) = i;
         i.prefix_inc();
     }
-    let mut map2: BTreeMap<i32, Box<i32>> = map1.clone();
+    let mut map2: BTreeMap<i32, Box<(i32, i32)>> = map1.clone();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        assert!(((*map2.entry(i).or_default().as_mut()) == (i)));
-        (*map2.entry(i).or_default().as_mut()).prefix_inc();
+        assert!(
+            ((*&mut map2
+                .entry(i.clone())
+                .or_insert_with(|| Box::new((i, <i32>::default())))
+                .1)
+                == (i))
+        );
+        (*&mut map2
+            .entry(i.clone())
+            .or_insert_with(|| Box::new((i, <i32>::default())))
+            .1)
+            .prefix_inc();
         i.prefix_inc();
     }
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        assert!(((*map1.entry(i).or_default().as_mut()) == (i)));
-        assert!(((*map2.entry(i).or_default().as_mut()) == ((i) + (1))));
+        assert!(
+            ((*&mut map1
+                .entry(i.clone())
+                .or_insert_with(|| Box::new((i, <i32>::default())))
+                .1)
+                == (i))
+        );
+        assert!(
+            ((*&mut map2
+                .entry(i.clone())
+                .or_insert_with(|| Box::new((i, <i32>::default())))
+                .1)
+                == ((i) + (1)))
+        );
         i.prefix_inc();
     }
     let mut pair1: (i32, i32) = (1.into(), 2.into());
diff --git a/tests/unit/out/unsafe/find.rs b/tests/unit/out/unsafe/find.rs
index fd11ca2e2..c2a3a498c 100644
--- a/tests/unit/out/unsafe/find.rs
+++ b/tests/unit/out/unsafe/find.rs
@@ -36,14 +36,23 @@ unsafe fn main_0() -> i32 {
         it
     };
     let mut v_result_true: bool = it != v.as_mut_ptr().add(v.len());
-    let mut m: BTreeMap<i32, Box<f64>> = BTreeMap::new();
-    (*m.entry(1).or_default().as_mut()) = 1_f64;
-    (*m.entry(2).or_default().as_mut()) = 2_f64;
-    (*m.entry(3).or_default().as_mut()) = 3_f64;
+    let mut m: BTreeMap<i32, Box<(i32, f64)>> = BTreeMap::new();
+    (*&mut m
+        .entry(1.clone())
+        .or_insert_with(|| Box::new((1, <f64>::default())))
+        .1) = 1_f64;
+    (*&mut m
+        .entry(2.clone())
+        .or_insert_with(|| Box::new((2, <f64>::default())))
+        .1) = 2_f64;
+    (*&mut m
+        .entry(3.clone())
+        .or_insert_with(|| Box::new((3, <f64>::default())))
+        .1) = 3_f64;
     let mut m_begin: UnsafeMapIterator<i32, f64> =
-        UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<f64>>);
+        UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, f64)>>);
     let mut m_end: UnsafeMapIterator<i32, f64> =
-        UnsafeMapIterator::end(&m as *const BTreeMap<i32, Box<f64>>);
+        UnsafeMapIterator::end(&m as *const BTreeMap<i32, Box<(i32, f64)>>);
     let mut m_result_true: bool = m_begin != m_end;
     assert!(
         ((v_result_true) && (m_result_true))
diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs
index 613c5e180..d61b91f92 100644
--- a/tests/unit/out/unsafe/foreach_map.rs
+++ b/tests/unit/out/unsafe/foreach_map.rs
@@ -13,24 +13,38 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut m: BTreeMap<i32, Box<f64>> = BTreeMap::new();
+    let mut m: BTreeMap<i32, Box<(i32, f64)>> = BTreeMap::new();
     let mut i: i32 = 0;
     let mut k: i32 = 100;
     'loop_: while ((i) < (100)) {
-        (*m.entry(i).or_default().as_mut()) = ((k as f64) / (2_f64));
+        (*&mut m
+            .entry(i.clone())
+            .or_insert_with(|| Box::new((i, <f64>::default())))
+            .1) = ((k as f64) / (2_f64));
         {
             i.prefix_inc();
             k.prefix_dec()
         };
     }
     let mut sum: f64 = 0_f64;
-    'loop_: for i in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<f64>>) {
-        sum += *i.second();
+    'loop_: for __begin1 in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, f64)>>) {
+        let i: *const (i32, f64) = &(*__begin1.deref());
+        sum += (*i).1;
     }
-    'loop_: for i in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<f64>>) {
-        sum += (*i.first() as f64);
+    'loop_: for __begin1 in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, f64)>>) {
+        let mut i: (i32, f64) = (*__begin1.deref()).clone();
+        sum += (i.0 as f64);
     }
     assert!(((sum) == (7475_f64)));
+    'loop_: for __begin1 in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, f64)>>) {
+        let mut i: (i32, f64) = (*__begin1.deref()).clone();
+        i.1 = (-1_i32 as f64);
+        assert!(((i.1) == (-1_i32 as f64)));
+    }
+    'loop_: for __begin1 in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, f64)>>) {
+        let i: *const (i32, f64) = &(*__begin1.deref());
+        assert!((((*i).1) != (-1_i32 as f64)));
+    }
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs
index 9292286bf..b92e11deb 100644
--- a/tests/unit/out/unsafe/map-reallocation.rs
+++ b/tests/unit/out/unsafe/map-reallocation.rs
@@ -15,13 +15,16 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let N: i32 = 10000;
     let sentinel: i32 = ((N) / (2));
-    let mut m: BTreeMap<i32, Box<i32>> = BTreeMap::new();
-    (*m.entry(sentinel).or_default().as_mut()) = sentinel;
+    let mut m: BTreeMap<i32, Box<(i32, i32)>> = BTreeMap::new();
+    (*&mut m
+        .entry(sentinel.clone())
+        .or_insert_with(|| Box::new((sentinel, <i32>::default())))
+        .1) = sentinel;
     let mut it: UnsafeMapIterator<i32, i32> =
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i32, Box<i32>>, &sentinel);
-    let mut p: *mut i32 = (&mut *it.second() as *mut i32);
+        UnsafeMapIterator::find_key(&m as *const BTreeMap<i32, Box<(i32, i32)>>, &sentinel);
+    let mut p: *mut i32 = (&mut *&raw mut (*it.deref()).1 as *mut i32);
     assert!(
-        ((*it.second()) == (sentinel))
+        ((*&raw mut (*it.deref()).1) == (sentinel))
             && (!(c"iterator does not have correct value before insert".as_ptr()).is_null())
     );
     assert!(
@@ -30,35 +33,48 @@ unsafe fn main_0() -> i32 {
     );
     let mut i: i32 = 0;
     'loop_: while ((i) < (sentinel)) {
-        (*m.entry(i).or_default().as_mut()) = i;
+        (*&mut m
+            .entry(i.clone())
+            .or_insert_with(|| Box::new((i, <i32>::default())))
+            .1) = i;
         i.prefix_inc();
     }
     let mut i: i32 = ((sentinel) + (1));
     'loop_: while ((i) <= (N)) {
-        (*m.entry(i).or_default().as_mut()) = i;
+        (*&mut m
+            .entry(i.clone())
+            .or_insert_with(|| Box::new((i, <i32>::default())))
+            .1) = i;
         i.prefix_inc();
     }
     assert!(
-        ((*it.second()) != (0))
+        ((*&raw mut (*it.deref()).1) != (0))
             && (!(c"in refcount, iterator points to index 0 instead of sentinel".as_ptr())
                 .is_null())
     );
     assert!(
-        ((*it.second()) == (sentinel))
+        ((*&raw mut (*it.deref()).1) == (sentinel))
             && (!(c"iterator does not have correct value after insert".as_ptr()).is_null())
     );
     assert!(
         ((*p) == (sentinel))
             && (!(c"pointer does not have correct value after insert".as_ptr()).is_null())
     );
-    *it.second() = 57005;
-    assert!(((*m.entry(sentinel).or_default().as_mut()) == (57005)));
+    *&raw mut (*it.deref()).1 = 57005;
+    assert!(
+        ((*&mut m
+            .entry(sentinel.clone())
+            .or_insert_with(|| Box::new((sentinel, <i32>::default())))
+            .1)
+            == (57005))
+    );
     assert!(((*p) == (57005)));
     assert!(((m.len()) == ((((N) + (1)) as u32) as usize)));
     let mut prev: i32 = -1_i32;
-    'loop_: for pair in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<i32>>) {
-        assert!(((*pair.first()) > (prev)));
-        prev = *pair.first();
+    'loop_: for __begin1 in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, i32)>>) {
+        let pair: *mut (i32, i32) = &mut (*__begin1.deref());
+        assert!((((*pair).0) > (prev)));
+        prev = (*pair).0;
     }
     return 0;
 }
diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs
index 2449d2de6..04f1bf3e8 100644
--- a/tests/unit/out/unsafe/map.rs
+++ b/tests/unit/out/unsafe/map.rs
@@ -19,96 +19,219 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut m: BTreeMap<i16, Box<u32>> = BTreeMap::new();
-    (*m.entry(0_i16).or_default().as_mut()) = 1_u32;
-    (*m.entry(1_i16).or_default().as_mut()) = 2_u32;
-    (*m.entry(2_i16).or_default().as_mut()) = 3_u32;
+    let mut m: BTreeMap<i16, Box<(i16, u32)>> = BTreeMap::new();
+    (*&mut m
+        .entry(0_i16.clone())
+        .or_insert_with(|| Box::new((0_i16, <u32>::default())))
+        .1) = 1_u32;
+    (*&mut m
+        .entry(1_i16.clone())
+        .or_insert_with(|| Box::new((1_i16, <u32>::default())))
+        .1) = 2_u32;
+    (*&mut m
+        .entry(2_i16.clone())
+        .or_insert_with(|| Box::new((2_i16, <u32>::default())))
+        .1) = 3_u32;
     assert!(((m.len()) == (3_usize)));
-    assert!(((*m.entry(0_i16).or_default().as_mut()) == (1_u32)));
-    assert!(((*m.entry(1_i16).or_default().as_mut()) == (2_u32)));
-    assert!(((*m.entry(2_i16).or_default().as_mut()) == (3_u32)));
+    assert!(
+        ((*&mut m
+            .entry(0_i16.clone())
+            .or_insert_with(|| Box::new((0_i16, <u32>::default())))
+            .1)
+            == (1_u32))
+    );
+    assert!(
+        ((*&mut m
+            .entry(1_i16.clone())
+            .or_insert_with(|| Box::new((1_i16, <u32>::default())))
+            .1)
+            == (2_u32))
+    );
+    assert!(
+        ((*&mut m
+            .entry(2_i16.clone())
+            .or_insert_with(|| Box::new((2_i16, <u32>::default())))
+            .1)
+            == (3_u32))
+    );
     let mut x: i32 = 4;
-    (*m.entry(1_i16).or_default().as_mut()) = (x as u32);
+    (*&mut m
+        .entry(1_i16.clone())
+        .or_insert_with(|| Box::new((1_i16, <u32>::default())))
+        .1) = (x as u32);
     assert!(((m.len()) == (3_usize)));
-    assert!(((*m.entry(0_i16).or_default().as_mut()) == (1_u32)));
-    assert!(((*m.entry(1_i16).or_default().as_mut()) == (4_u32)));
-    assert!(((*m.entry(2_i16).or_default().as_mut()) == (3_u32)));
-    (unsafe { foo_0((*m.entry(0_i16).or_default().as_mut())) });
-    assert!(((*m.entry(0_i16).or_default().as_mut()) == (1_u32)));
-    (unsafe { bar_1(&mut (*m.entry(2_i16).or_default().as_mut())) });
-    assert!(((*m.entry(2_i16).or_default().as_mut()) == (4_u32)));
-    (*m.entry(0_i16).or_default().as_mut()) = (*m.entry(0_i16).or_default().as_mut())
-        .wrapping_add((*m.entry(2_i16).or_default().as_mut()));
-    assert!(((*m.entry(0_i16).or_default().as_mut()) == (5_u32)));
+    assert!(
+        ((*&mut m
+            .entry(0_i16.clone())
+            .or_insert_with(|| Box::new((0_i16, <u32>::default())))
+            .1)
+            == (1_u32))
+    );
+    assert!(
+        ((*&mut m
+            .entry(1_i16.clone())
+            .or_insert_with(|| Box::new((1_i16, <u32>::default())))
+            .1)
+            == (4_u32))
+    );
+    assert!(
+        ((*&mut m
+            .entry(2_i16.clone())
+            .or_insert_with(|| Box::new((2_i16, <u32>::default())))
+            .1)
+            == (3_u32))
+    );
+    (unsafe {
+        foo_0(
+            (*&mut m
+                .entry(0_i16.clone())
+                .or_insert_with(|| Box::new((0_i16, <u32>::default())))
+                .1),
+        )
+    });
+    assert!(
+        ((*&mut m
+            .entry(0_i16.clone())
+            .or_insert_with(|| Box::new((0_i16, <u32>::default())))
+            .1)
+            == (1_u32))
+    );
+    (unsafe {
+        bar_1(
+            &mut (*&mut m
+                .entry(2_i16.clone())
+                .or_insert_with(|| Box::new((2_i16, <u32>::default())))
+                .1),
+        )
+    });
+    assert!(
+        ((*&mut m
+            .entry(2_i16.clone())
+            .or_insert_with(|| Box::new((2_i16, <u32>::default())))
+            .1)
+            == (4_u32))
+    );
+    (*&mut m
+        .entry(0_i16.clone())
+        .or_insert_with(|| Box::new((0_i16, <u32>::default())))
+        .1) = (*&mut m
+        .entry(0_i16.clone())
+        .or_insert_with(|| Box::new((0_i16, <u32>::default())))
+        .1)
+        .wrapping_add(
+            (*&mut m
+                .entry(2_i16.clone())
+                .or_insert_with(|| Box::new((2_i16, <u32>::default())))
+                .1),
+        );
+    assert!(
+        ((*&mut m
+            .entry(0_i16.clone())
+            .or_insert_with(|| Box::new((0_i16, <u32>::default())))
+            .1)
+            == (5_u32))
+    );
     let mut end: UnsafeMapIterator<i16, u32> =
-        UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<u32>>);
+        UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<(i16, u32)>>);
     let mut it: UnsafeMapIterator<i16, u32> =
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<u32>>, &1_i16);
+        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<(i16, u32)>>, &1_i16);
     let mut const_it: UnsafeMapIterator<i16, u32> =
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<u32>>, &10_i16).clone();
-    let mut x1: u32 = if it == end { 0_u32 } else { *it.second() };
+        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<(i16, u32)>>, &10_i16).clone();
+    let mut x1: u32 = if it == end {
+        0_u32
+    } else {
+        *&raw mut (*it.deref()).1
+    };
     assert!(((x1) == (4_u32)));
     let mut x2: u32 = if const_it == end.clone() {
         0_u32
     } else {
-        *const_it.second()
+        *&raw mut (*const_it.deref()).1
     };
     assert!(((x2) == (0_u32)));
-    let mut x3: u32 = if it == UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<u32>>) {
+    let mut x3: u32 = if it == UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<(i16, u32)>>) {
         0_u32
     } else {
-        *it.second()
+        *&raw mut (*it.deref()).1
     };
     assert!(((x3) == (4_u32)));
-    let mut x4: u32 =
-        if const_it == UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<u32>>).clone() {
-            0_u32
-        } else {
-            *const_it.second()
-        };
+    let mut x4: u32 = if const_it
+        == UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<(i16, u32)>>).clone()
+    {
+        0_u32
+    } else {
+        *&raw mut (*const_it.deref()).1
+    };
     assert!(((x4) == (0_u32)));
-    (*m.entry(4_i16).or_default().as_mut()) = 5_u32;
+    (*&mut m
+        .entry(4_i16.clone())
+        .or_insert_with(|| Box::new((4_i16, <u32>::default())))
+        .1) = 5_u32;
     let mut it4: UnsafeMapIterator<i16, u32> =
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<u32>>, &4_i16);
-    let mut p: *mut u32 = (&mut *it4.second() as *mut u32);
+        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<(i16, u32)>>, &4_i16);
+    let mut p: *mut u32 = (&mut *&raw mut (*it4.deref()).1 as *mut u32);
     let mut x5: u32 = (*p);
-    assert!(((*m.entry(4_i16).or_default().as_mut()) == (5_u32)));
-    assert!(((*it4.second()) == (5_u32)));
+    assert!(
+        ((*&mut m
+            .entry(4_i16.clone())
+            .or_insert_with(|| Box::new((4_i16, <u32>::default())))
+            .1)
+            == (5_u32))
+    );
+    assert!(((*&raw mut (*it4.deref()).1) == (5_u32)));
     assert!(((*p) == (5_u32)));
     assert!(((x5) == (5_u32)));
     (*p).prefix_inc();
-    assert!(((*m.entry(4_i16).or_default().as_mut()) == (6_u32)));
-    assert!(((*it4.second()) == (6_u32)));
+    assert!(
+        ((*&mut m
+            .entry(4_i16.clone())
+            .or_insert_with(|| Box::new((4_i16, <u32>::default())))
+            .1)
+            == (6_u32))
+    );
+    assert!(((*&raw mut (*it4.deref()).1) == (6_u32)));
     assert!(((*p) == (6_u32)));
     assert!(((x5) == (5_u32)));
-    let r: *mut BTreeMap<i16, Box<u32>> = &mut m;
+    let r: *mut BTreeMap<i16, Box<(i16, u32)>> = &mut m;
     assert!((((*r).len()) == (4_usize)));
     assert!(
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<u32>>, &4_i16)
-            != UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<u32>>)
+        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<(i16, u32)>>, &4_i16)
+            != UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<(i16, u32)>>)
     );
-    UnsafeMapIterator::erase(&(*r) as *const BTreeMap<i16, Box<u32>>, &it4.clone());
+    UnsafeMapIterator::erase(&(*r) as *const BTreeMap<i16, Box<(i16, u32)>>, &it4.clone());
     assert!((((*r).len()) == (3_usize)));
     assert!(
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<u32>>, &4_i16)
-            == UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<u32>>)
+        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<(i16, u32)>>, &4_i16)
+            == UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<(i16, u32)>>)
     );
-    let mut other_map: BTreeMap<(i32, i64), Box<f64>> = BTreeMap::new();
+    let mut other_map: BTreeMap<(i32, i64), Box<((i32, i64), f64)>> = BTreeMap::new();
     assert!(((other_map.len()) == (0_usize)));
     let mut key0: (i32, i64) = (1.into(), 1.into());
     let mut value: f64 = 2_f64;
-    (*other_map.entry((key0).clone()).or_default().as_mut()) = value;
-    value = (*other_map.entry((key0).clone()).or_default().as_mut());
+    (*&mut other_map
+        .entry(key0.clone())
+        .or_insert_with(|| Box::new((key0, <f64>::default())))
+        .1) = value;
+    value = (*&mut other_map
+        .entry(key0.clone())
+        .or_insert_with(|| Box::new((key0, <f64>::default())))
+        .1);
     assert!(((other_map.len()) == (1_usize)));
-    assert!(((*other_map.entry((key0).clone()).or_default().as_mut()) == (value)));
+    assert!(
+        ((*&mut other_map
+            .entry(key0.clone())
+            .or_insert_with(|| Box::new((key0, <f64>::default())))
+            .1)
+            == (value))
+    );
     assert!(((m.len()) == (3_usize)));
     let mut k: i32 = 0;
-    assert!(((*(m.get(&(k as i16)).expect("out of range!").as_ref() as *const u32)) == (5_u32)));
+    assert!(((*(&m.get(&(k as i16)).expect("out of range!").1 as *const u32)) == (5_u32)));
     k.prefix_inc();
-    assert!(((*(m.get(&(k as i16)).expect("out of range!").as_ref() as *const u32)) == (4_u32)));
+    assert!(((*(&m.get(&(k as i16)).expect("out of range!").1 as *const u32)) == (4_u32)));
     k.prefix_inc();
-    assert!(((*(m.get(&(k as i16)).expect("out of range!").as_ref() as *const u32)) == (4_u32)));
-    let mut m2: BTreeMap<i32, Box<bool>> = BTreeMap::new();
+    assert!(((*(&m.get(&(k as i16)).expect("out of range!").1 as *const u32)) == (4_u32)));
+    let mut m2: BTreeMap<i32, Box<(i32, bool)>> = BTreeMap::new();
     assert!(((m2.len()) == (0_usize)));
     let mut indexes: Vec<i32> = Vec::new();
     let mut i: u32 = 60_u32;
@@ -137,18 +260,23 @@ unsafe fn main_0() -> i32 {
     }
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < (indexes.len())) {
-        (*m2.entry(indexes[(i as usize)]).or_default().as_mut()) = ((i).wrapping_rem(2_u32) != 0);
+        (*&mut m2
+            .entry(indexes[(i as usize)].clone())
+            .or_insert_with(|| Box::new((indexes[(i as usize)], <bool>::default())))
+            .1) = ((i).wrapping_rem(2_u32) != 0);
         i.prefix_inc();
     }
     assert!(((m2.len()) == (indexes.len())));
     let mut last: i32 = -1_i32;
-    'loop_: for pair in UnsafeMapIterator::begin(&m2 as *const BTreeMap<i32, Box<bool>>) {
-        assert!(((*pair.first()) > (last)));
-        assert!(((*pair.second() as i32) == ((*pair.first()) % (2))));
-        last = *pair.first();
+    'loop_: for __begin1 in UnsafeMapIterator::begin(&m2 as *const BTreeMap<i32, Box<(i32, bool)>>)
+    {
+        let pair: *mut (i32, bool) = &mut (*__begin1.deref());
+        assert!((((*pair).0) > (last)));
+        assert!((((*pair).1 as i32) == (((*pair).0) % (2))));
+        last = (*pair).0;
     }
     k = 0;
-    let value_0: *const u32 = (m.get(&(k as i16)).expect("out of range!").as_ref() as *const u32);
+    let value_0: *const u32 = (&m.get(&(k as i16)).expect("out of range!").1 as *const u32);
     assert!(
         ((((((((m.len()).wrapping_add((x1 as usize))).wrapping_add((x2 as usize)))
             .wrapping_add((x3 as usize)))
diff --git a/tests/unit/out/unsafe/operator_traits.rs b/tests/unit/out/unsafe/operator_traits.rs
index 2fef72638..cf3a90ebb 100644
--- a/tests/unit/out/unsafe/operator_traits.rs
+++ b/tests/unit/out/unsafe/operator_traits.rs
@@ -210,11 +210,27 @@ unsafe fn main_0() -> i32 {
         })
         .v) == (2))
     );
-    let mut m: BTreeMap<Lt, Box<i32>> = BTreeMap::new();
-    (*m.entry(Lt { v: 2 }).or_default().as_mut()) = 20;
-    (*m.entry(Lt { v: 1 }).or_default().as_mut()) = 10;
-    assert!(((*UnsafeMapIterator::begin(&m as *const BTreeMap<Lt, Box<i32>>).second()) == (10)));
-    assert!(((*m.entry(Lt { v: 2 }).or_default().as_mut()) == (20)));
+    let mut m: BTreeMap<Lt, Box<(Lt, i32)>> = BTreeMap::new();
+    (*&mut m
+        .entry(Lt { v: 2 }.clone())
+        .or_insert_with(|| Box::new((Lt { v: 2 }, <i32>::default())))
+        .1) = 20;
+    (*&mut m
+        .entry(Lt { v: 1 }.clone())
+        .or_insert_with(|| Box::new((Lt { v: 1 }, <i32>::default())))
+        .1) = 10;
+    assert!(
+        ((*&raw mut (*UnsafeMapIterator::begin(&m as *const BTreeMap<Lt, Box<(Lt, i32)>>)
+            .deref())
+        .1) == (10))
+    );
+    assert!(
+        ((*&mut m
+            .entry(Lt { v: 2 }.clone())
+            .or_insert_with(|| Box::new((Lt { v: 2 }, <i32>::default())))
+            .1)
+            == (20))
+    );
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
index 7aca02a35..958193e7b 100644
--- a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
@@ -8,7 +8,11 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn sink_0(mut it: UnsafeMapIterator<i32, i32>) -> i32 {
     let mut cit: UnsafeMapIterator<i32, i32> = it.clone();
-    return if cit == it.clone() { *it.second() } else { 0 };
+    return if cit == it.clone() {
+        *&raw mut (*it.deref()).1
+    } else {
+        0
+    };
 }
 pub fn main() {
     unsafe {
@@ -17,12 +21,15 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut m: BTreeMap<i32, Box<i32>> = BTreeMap::new();
-    (*m.entry(0).or_default().as_mut()) = 1;
+    let mut m: BTreeMap<i32, Box<(i32, i32)>> = BTreeMap::new();
+    (*&mut m
+        .entry(0.clone())
+        .or_insert_with(|| Box::new((0, <i32>::default())))
+        .1) = 1;
     let mut end: UnsafeMapIterator<i32, i32> =
-        UnsafeMapIterator::end(&m as *const BTreeMap<i32, Box<i32>>);
+        UnsafeMapIterator::end(&m as *const BTreeMap<i32, Box<(i32, i32)>>);
     let mut it0: UnsafeMapIterator<i32, i32> =
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i32, Box<i32>>, &0);
+        UnsafeMapIterator::find_key(&m as *const BTreeMap<i32, Box<(i32, i32)>>, &0);
     let mut const_it: UnsafeMapIterator<i32, i32> = it0.clone();
     let mut r: i32 = if const_it == end.clone() { 0 } else { 1 };
     r += (unsafe { sink_0(it0.clone()) });