diff --git a/CMakeLists.txt b/CMakeLists.txt
index 933b9a235..7ff650e9a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -179,6 +179,9 @@ file(GLOB_RECURSE rule_preprocessor_sources
 file(GLOB_RECURSE libcc2rs_sources CONFIGURE_DEPENDS
      ${PROJECT_SOURCE_DIR}/libcc2rs/src/*.rs
      ${PROJECT_SOURCE_DIR}/libcc2rs-macros/src/*.rs)
+file(GLOB rule_shim_sources CONFIGURE_DEPENDS
+     ${PROJECT_SOURCE_DIR}/rules/*/shim.rs)
+list(APPEND libcc2rs_sources ${rule_shim_sources})
 list(APPEND libcc2rs_sources
      ${PROJECT_SOURCE_DIR}/libcc2rs/Cargo.toml
      ${PROJECT_SOURCE_DIR}/libcc2rs-macros/Cargo.toml)
diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index fdc619bb9..dae3b5916 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -793,21 +793,6 @@ bool Converter::RecordHasCopyableFields(const clang::RecordDecl *decl) {
     return false;
   }
   for (auto f : decl->fields()) {
-    // Records that contain std::vector, std::array, std::string or anything
-    // that is translated to Vec<>, do not derive Copy
-    auto mapped = Mapper::Map(*this, f->getType());
-    if (mapped.starts_with("Vec<")) {
-      return false;
-    }
-
-    if (IsUniquePtr(f->getType())) {
-      return false;
-    }
-
-    if (mapped.starts_with("BTreeMap<")) {
-      return false;
-    }
-
     if (auto ptr_ty = f->getType()->getAs<clang::PointerType>()) {
       if (ptr_ty->getPointeeType()->isFunctionType()) {
         if (!FunctionPointerImplementsCopy()) {
@@ -1575,7 +1560,7 @@ bool Converter::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
   StrCat("'loop_:");
   auto map_type = Mapper::Map(*this, stmt->getRangeInit()->getType());
   StrCat(keyword::kFor, GetNamedDeclAsString(begin), keyword::kIn,
-         "UnsafeMapIterator::begin(&");
+         "UnsafeMap::range(&");
   Convert(stmt->getRangeInit());
   StrCat(std::format(" as *const {})", map_type));
   {
@@ -3362,9 +3347,6 @@ bool Converter::ConvertCXXOperatorCallExpr(clang::CXXOperatorCallExpr *expr) {
   case clang::OverloadedOperatorKind::OO_Arrow:
     if (IsUniquePtr(expr->getArg(0)->getType())) {
       ConvertUniquePtrDeref(expr);
-    } else if (GetStrongestIteratorCategory(ctx_, expr->getArg(0)->getType()) ==
-               IteratorCategory::Bidirectional) {
-      Convert(expr->getArg(0));
     } else if (expr->getOperator() == clang::OverloadedOperatorKind::OO_Star) {
       PushParen paren(*this);
       StrCat(token::kStar);
@@ -3914,8 +3896,6 @@ void Converter::ConvertCXXConstructExprArgs(clang::CXXConstructExpr *expr) {
 }
 
 bool Converter::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
-  PushSuppressIteratorClone push(*this, expr);
-
   if (expr->isElidable()) {
     Convert(expr->getArg(0));
     return false;
@@ -3938,11 +3918,9 @@ bool Converter::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
     return false;
   }
   if (IsPassThroughConstructor(ctor)) {
-    // Take suppress before recursing into the child.
-    bool suppress = PushSuppressIteratorClone::take(*this);
     Convert(expr->getArg(0));
     if ((ctor->isCopyConstructor() || IsDefaultedMoveConstructor(ctor)) &&
-        !suppress && !TypeIsCopyable(expr->getType())) {
+        !TypeIsCopyable(expr->getType())) {
       StrCat(".clone()");
       SetFreshType(expr->getType());
     }
@@ -5452,14 +5430,6 @@ void Converter::ConvertConstructFromArgs(clang::QualType type,
 std::string Converter::AccessLValueObject(clang::MemberExpr *member) {
   auto *object = member->getBase();
   auto type = object->getType();
-  if (member->isArrow()) {
-    auto *op =
-        clang::dyn_cast<clang::CXXOperatorCallExpr>(object->IgnoreImplicit());
-    if (op && GetStrongestIteratorCategory(ctx_, op->getArg(0)->getType()) ==
-                  IteratorCategory::Bidirectional) {
-      return ToString(object);
-    }
-  }
   if (type->isPointerType() ||
       (IsReferenceType(object) && clang::isa<clang::CallExpr>(object))) {
     return std::format("({}{})", GetPointerDerefPrefix(type->getPointeeType()),
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index f79c57995..201018834 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -841,7 +841,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   std::string ufcs_receiver_;
   bool in_const_initializer_ = false;
   std::optional<bool> autoref_mut_;
-  bool suppress_iterator_clone_ = false;
 
   struct PushExplicitAutoref {
     Converter &c;
@@ -853,41 +852,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     ~PushExplicitAutoref() { c.autoref_mut_ = prev; }
   };
 
-  struct PushSuppressIteratorClone {
-    Converter &c;
-    bool prev;
-    PushSuppressIteratorClone(Converter &c, clang::CXXConstructExpr *expr)
-        : c(c), prev(c.suppress_iterator_clone_) {
-      auto *ctor = expr->getConstructor();
-      if (!ctor->isCopyOrMoveConstructor() &&
-          ctor->isConvertingConstructor(/*AllowExplicit=*/false) &&
-          ctor->getNumParams() == 1 && IsIteratorType(expr->getType())) {
-        c.suppress_iterator_clone_ = true;
-      }
-    }
-    ~PushSuppressIteratorClone() { c.suppress_iterator_clone_ = prev; }
-    PushSuppressIteratorClone(const PushSuppressIteratorClone &) = delete;
-    PushSuppressIteratorClone &
-    operator=(const PushSuppressIteratorClone &) = delete;
-
-    static bool take(Converter &c) {
-      return std::exchange(c.suppress_iterator_clone_, false);
-    }
-
-  private:
-    static bool IsIteratorType(clang::QualType qt) {
-      if (auto *record = qt->getAsCXXRecordDecl()) {
-        for (auto *d : record->decls()) {
-          if (auto *tnd = llvm::dyn_cast<clang::TypedefNameDecl>(d)) {
-            if (tnd->getName() == "iterator_category")
-              return true;
-          }
-        }
-      }
-      return false;
-    }
-  };
-
   struct PushConstInitializer {
     Converter &c;
     bool prev;
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index 0216b18c7..c516fefe5 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -1892,7 +1892,7 @@ clang::Expr *GetCallee(clang::CallExpr *expr) {
 }
 
 bool HasReceiver(clang::Expr *expr) {
-  if (clang::isa<clang::CXXMemberCallExpr>(expr))
+  if (clang::isa<clang::CXXMemberCallExpr, clang::MemberExpr>(expr))
     return true;
   if (auto *opcall = clang::dyn_cast<clang::CXXOperatorCallExpr>(expr)) {
     if (auto *callee = opcall->getCalleeDecl()) {
@@ -1920,26 +1920,6 @@ std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
   return fn->getParamDecl(param_idx)->getType().getNonReferenceType();
 }
 
-std::optional<IteratorCategory>
-GetStrongestIteratorCategory(clang::ASTContext &ctx, clang::QualType type) {
-  type = type.getNonReferenceType().getUnqualifiedType();
-  if (!Mapper::Contains(ctx, type)) {
-    return std::nullopt;
-  }
-  if (RuleRegistry::MapsToRefcountPointer(ctx, type)) {
-    return IteratorCategory::Contiguous;
-  }
-  auto mapped = Mapper::Map(ctx, type);
-  if (mapped.empty()) {
-    return std::nullopt;
-  }
-  if (mapped.starts_with("RefcountMapIter<") ||
-      mapped.starts_with("UnsafeMapIterator<")) {
-    return IteratorCategory::Bidirectional;
-  }
-  return std::nullopt;
-}
-
 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 19f35152b..f8511750d 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -28,17 +28,6 @@ class Sema;
 
 namespace cpp2rust {
 
-// Order matters: each category is a superset of the previous one.
-// Use >= to check "at least this capable".
-enum class IteratorCategory {
-  Forward,
-  Bidirectional,
-  RandomAccess,
-  Contiguous,
-};
-
-std::optional<IteratorCategory>
-GetStrongestIteratorCategory(clang::ASTContext &ctx, clang::QualType type);
 bool IsBuiltinConstantP(const clang::Expr *expr);
 
 bool IsGlobalVar(const clang::VarDecl *decl);
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 1bd1af1a9..d2854addd 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -97,8 +97,8 @@ static bool IsFieldOfVectorElem(const clang::MemberExpr *expr) {
 }
 
 static bool IsPointerType(clang::ASTContext &ctx, clang::QualType type) {
-  return type->isPointerType() || GetStrongestIteratorCategory(ctx, type) ==
-                                      IteratorCategory::Contiguous;
+  return type->isPointerType() ||
+         RuleRegistry::MapsToRefcountPointer(ctx, type);
 }
 
 void ConverterRefCount::PendingDeref::set(std::string str, bool fresh) {
@@ -2279,7 +2279,7 @@ bool ConverterRefCount::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
   auto begin_name = GetNamedDeclAsString(begin);
 
   StrCat("'loop_:");
-  StrCat(keyword::kFor, begin_name, keyword::kIn, "RefcountMapIter::begin(",
+  StrCat(keyword::kFor, begin_name, keyword::kIn, "Map::range(",
          ConvertObject(stmt->getRangeInit()), ')');
   PushBrace brace(*this);
 
@@ -2375,7 +2375,6 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
                      getConversionKind() != ConversionKind::Unboxed;
   PushConversionKind push(*this, boxed_array ? ConversionKind::Pointee
                                              : ConversionKind::Unboxed);
-  PushSuppressIteratorClone push_suppress(*this, expr);
 
   if (auto str = GetMappedAsString(expr, expr->getArgs(), expr->getNumArgs());
       !str.empty()) {
@@ -2408,9 +2407,7 @@ bool ConverterRefCount::VisitCXXConstructExpr(clang::CXXConstructExpr *expr) {
 
   if (ctor->isCopyOrMoveConstructor() &&
       !IsConvertibleCopyOrMoveConstructor(ctor)) {
-    StrCat(PushSuppressIteratorClone::take(*this)
-               ? ConvertRValue(expr->getArg(0))
-               : ConvertFreshRValue(expr->getArg(0)));
+    StrCat(ConvertFreshRValue(expr->getArg(0)));
     return false;
   }
 
@@ -2848,12 +2845,6 @@ bool ConverterRefCount::ConvertCXXOperatorCallExpr(
       break;
     }
 
-    if (GetStrongestIteratorCategory(ctx_, expr->getArg(0)->getType()) ==
-        IteratorCategory::Bidirectional) {
-      Convert(expr->getArg(0));
-      break;
-    }
-
     {
       bool deref = !isAddrOf();
       PushParen paren(*this, deref);
@@ -3314,7 +3305,8 @@ void ConverterRefCount::ConvertArrow(clang::Expr *expr) {
   bool is_overloaded_arrow =
       op && op->getOperator() == clang::OverloadedOperatorKind::OO_Arrow;
 
-  if (!is_overloaded_arrow || IsUserOperatorCall(op)) {
+  if (!is_overloaded_arrow || IsUserOperatorCall(op) ||
+      RuleRegistry::ReturnsPointer(ctx_, expr)) {
     auto pointee_type = expr->getType()->getPointeeType();
     // Virtual methods, which take &mut self, are called through PtrDyn.
     if (auto *record = pointee_type->getAsRecordDecl();
@@ -3333,12 +3325,6 @@ void ConverterRefCount::ConvertArrow(clang::Expr *expr) {
     return;
   }
 
-  if (GetStrongestIteratorCategory(ctx_, op->getArg(0)->getType()) ==
-      IteratorCategory::Bidirectional) {
-    Convert(op->getArg(0));
-    return;
-  }
-
   Convert(expr);
 }
 
@@ -3348,12 +3334,6 @@ std::string ConverterRefCount::AccessLValueObject(clang::MemberExpr *member) {
 
   bool is_mut = method && !method->isConst();
   if (member->isArrow()) {
-    auto *op =
-        clang::dyn_cast<clang::CXXOperatorCallExpr>(object->IgnoreImplicit());
-    if (op && GetStrongestIteratorCategory(ctx_, op->getArg(0)->getType()) ==
-                  IteratorCategory::Bidirectional) {
-      return ConvertRValue(op->getArg(0));
-    }
     auto str = is_mut ? ConvertLValue(object) : ConvertRValue(object);
     auto pointee_type = object->getType()->getPointeeType();
     return DerefPtrExpr(str, pointee_type);
diff --git a/cpp2rust/converter/rules/decls.cpp b/cpp2rust/converter/rules/decls.cpp
index c621e1d70..90dac3789 100644
--- a/cpp2rust/converter/rules/decls.cpp
+++ b/cpp2rust/converter/rules/decls.cpp
@@ -77,30 +77,6 @@ const clang::Expr *GetMacroMemberBase(const clang::SourceManager &sm,
   }
 }
 
-clang::QualType EnableIfSameType(const clang::Decl *rule) {
-  auto tmpl = llvm::dyn_cast<clang::TemplateDecl>(rule);
-  if (!tmpl) {
-    return {};
-  }
-  for (auto param : *tmpl->getTemplateParameters()) {
-    auto type_param = llvm::dyn_cast<clang::TemplateTypeParmDecl>(param);
-    if (!type_param || type_param->getIdentifier() ||
-        !type_param->hasDefaultArgument()) {
-      continue;
-    }
-    auto same = type_param->getDefaultArgument()
-                    .getArgument()
-                    .getAsType()
-                    ->getAs<clang::TemplateSpecializationType>();
-    if (!same || !same->isTypeAlias() ||
-        same->getTemplateName().getAsTemplateDecl()->getName() != "SameAs") {
-      continue;
-    }
-    return same->template_arguments()[1].getAsType();
-  }
-  return {};
-}
-
 std::optional<std::vector<clang::TemplateArgument>>
 DeduceFromType(clang::Sema &sema, clang::TemplateParameterList *params,
                clang::QualType pattern, clang::QualType actual) {
diff --git a/cpp2rust/converter/rules/decls.h b/cpp2rust/converter/rules/decls.h
index 6c97da7c8..2ab5a2729 100644
--- a/cpp2rust/converter/rules/decls.h
+++ b/cpp2rust/converter/rules/decls.h
@@ -42,8 +42,6 @@ const clang::Expr *GetReturned(const clang::FunctionDecl *rule);
 const clang::Expr *GetMacroMemberBase(const clang::SourceManager &sm,
                                       const clang::MemberExpr *member);
 
-clang::QualType EnableIfSameType(const clang::Decl *rule);
-
 std::optional<std::vector<clang::TemplateArgument>>
 DeduceFromType(clang::Sema &sema, clang::TemplateParameterList *params,
                clang::QualType pattern, clang::QualType actual);
diff --git a/cpp2rust/converter/rules/expr_matcher.cpp b/cpp2rust/converter/rules/expr_matcher.cpp
index fd7860db2..2eb8c9b19 100644
--- a/cpp2rust/converter/rules/expr_matcher.cpp
+++ b/cpp2rust/converter/rules/expr_matcher.cpp
@@ -155,10 +155,6 @@ std::vector<clang::Expr *> getOperands(clang::ASTContext &ctx,
     auto base =
         const_cast<clang::Expr *>(macro_base ? macro_base : member->getBase())
             ->IgnoreParenImpCasts();
-    if (auto arrow = llvm::dyn_cast<clang::CXXOperatorCallExpr>(base);
-        arrow && arrow->getOperator() == clang::OO_Arrow) {
-      base = arrow->getArg(0);
-    }
     operands.push_back(getObject(ctx, base));
   }
   while (!operands.empty() &&
diff --git a/cpp2rust/converter/rules/registry.cpp b/cpp2rust/converter/rules/registry.cpp
index c4aabadcc..fd19c1722 100644
--- a/cpp2rust/converter/rules/registry.cpp
+++ b/cpp2rust/converter/rules/registry.cpp
@@ -22,6 +22,7 @@
 #include <variant>
 
 #include "converter/converter_lib.h"
+#include "converter/rules/decls.h"
 #include "converter/rules/expr_matcher.h"
 #include "converter/rules/rule_keys.h"
 #include "converter/rules/rules_loader.h"
@@ -83,6 +84,40 @@ clang::QualType getInitPattern(const clang::FunctionDecl *rule) {
   return alias->template_arguments()[0].getAsType();
 }
 
+void collectGenerics(const std::vector<TranslationRule::BodyFragment> &body,
+                     std::unordered_set<unsigned> &used) {
+  for (const auto &fragment : body) {
+    if (auto generic =
+            std::get_if<TranslationRule::GenericFragment>(&fragment)) {
+      used.insert(generic->n);
+    } else if (auto call = std::get_if<
+                   std::unique_ptr<TranslationRule::MethodCallFragment>>(
+                   &fragment)) {
+      collectGenerics((*call)->receiver, used);
+      collectGenerics((*call)->body, used);
+    }
+  }
+}
+
+void collectGenerics(llvm::StringRef type, std::unordered_set<unsigned> &used) {
+  auto is_ident = [](char c) { return llvm::isAlnum(c) || c == '_'; };
+  for (size_t i = 0; i < type.size(); ++i) {
+    if (type[i] != 'T' || (i > 0 && is_ident(type[i - 1]))) {
+      continue;
+    }
+    size_t end = i + 1;
+    while (end < type.size() && llvm::isDigit(type[end])) {
+      ++end;
+    }
+    unsigned n = 0;
+    if (end > i + 1 && (end == type.size() || !is_ident(type[end])) &&
+        !type.slice(i + 1, end).getAsInteger(10, n)) {
+      used.insert(n);
+    }
+    i = end - 1;
+  }
+}
+
 void checkGenerics(const std::string &dir, const std::string &name,
                    const clang::FunctionDecl *decl,
                    const TranslationRule::ExprRule &rule) {
@@ -92,10 +127,16 @@ void checkGenerics(const std::string &dir, const std::string &name,
       declared.insert(param->getName().str());
     }
   }
-  for (unsigned i = 1; i <= rule.generics.size(); ++i) {
+  std::unordered_set<unsigned> used;
+  collectGenerics(rule.body, used);
+  collectGenerics(rule.return_type.type, used);
+  for (const auto &param : rule.params) {
+    collectGenerics(param.type, used);
+  }
+  for (unsigned i : used) {
     if (!declared.contains(std::format("T{}", i))) {
       llvm::errs() << dir << "::" << name << ": generic T" << i
-                   << " declared but missing from src\n";
+                   << " used by the target but missing from src\n";
       llvm::report_fatal_error("Absent generic from src");
     }
   }
@@ -211,6 +252,13 @@ ExprMatch findExpr(const clang::Expr *use) {
   if (auto member = std::get_if<RuleKeys::Member>(&*key)) {
     consider(RuleKeys::Unqualified{member->name});
   }
+  if (std::holds_alternative<RuleKeys::Constructor>(*key)) {
+    auto type = RuleDecls::SkipImplicit(use)->getType();
+    if (auto record = type.getCanonicalType()->getAsCXXRecordDecl();
+        record && !type->isDependentType() && !IsUserDefinedDecl(record)) {
+      consider(RuleKeys::kAnyConstructor);
+    }
+  }
   return best;
 }
 
@@ -236,6 +284,9 @@ TypeRuleMatch findType(clang::QualType use) {
           auto better = AstMatcher::MoreSpecializedType(*sema_, it->second.decl,
                                                         best.rule_decl->decl);
           if (!better) {
+            use.dump(llvm::errs(), sema_->Context);
+            it->second.decl->dump(llvm::errs());
+            best.rule_decl->decl->dump(llvm::errs());
             llvm::report_fatal_error(
                 "type matches several rules, none more specialized");
           }
diff --git a/cpp2rust/converter/rules/rule_keys.cpp b/cpp2rust/converter/rules/rule_keys.cpp
index 3ad820322..98e263396 100644
--- a/cpp2rust/converter/rules/rule_keys.cpp
+++ b/cpp2rust/converter/rules/rule_keys.cpp
@@ -15,6 +15,7 @@
 #include <optional>
 #include <vector>
 
+#include "converter/converter_lib.h"
 #include "converter/rules/decls.h"
 
 namespace cpp2rust::RuleKeys {
@@ -205,6 +206,12 @@ std::vector<ExprKey> GetExprKeys(clang::ASTContext &ctx,
           llvm::dyn_cast<clang::CXXUnresolvedConstructExpr>(returned)) {
     std::vector<ExprKey> keys;
     for (auto type : resolveMemberType(construct->getTypeAsWritten())) {
+      if (type->getAs<clang::TemplateTypeParmType>()) {
+        if (!llvm::is_contained(keys, ExprKey{kAnyConstructor})) {
+          keys.push_back(kAnyConstructor);
+        }
+        continue;
+      }
       auto key = getConstructorKey(getParent(type));
       assert(key && "expression rule has no key");
       if (!llvm::is_contained(keys, *key)) {
@@ -240,18 +247,7 @@ std::vector<TypeKey> GetTypeKeys(const clang::NamedDecl *rule) {
   assert(alias && "type rule is not an alias");
   auto pattern = alias->getUnderlyingType();
   if (pattern->getAs<clang::TemplateTypeParmType>()) {
-    pattern = RuleDecls::EnableIfSameType(rule);
-    assert(!pattern.isNull() &&
-           "type rule matching any type must be constrained by enable_if");
-    std::vector<TypeKey> keys;
-    for (auto type : resolveMemberType(pattern)) {
-      auto key = GetTypeKey(type);
-      assert(key && "type rule has no key");
-      if (!llvm::is_contained(keys, *key)) {
-        keys.push_back(*key);
-      }
-    }
-    return keys;
+    return {kAnyClass};
   }
   if (auto member = pattern->getAs<clang::DependentNameType>()) {
     auto qualifier = member->getQualifier().getAsType();
@@ -270,6 +266,10 @@ std::vector<TypeKey> GetTypeKeys(clang::ASTContext &ctx, clang::QualType use) {
   if (auto key = GetTypeKey(use)) {
     keys.push_back(*key);
   }
+  if (auto record = use.getCanonicalType()->getAsCXXRecordDecl();
+      record && !use->isDependentType() && !IsUserDefinedDecl(record)) {
+    keys.push_back(kAnyClass);
+  }
   for (auto type = use;; type = type.getSingleStepDesugaredType(ctx)) {
     if (auto typedef_type =
             llvm::dyn_cast<clang::TypedefType>(type.getTypePtr())) {
diff --git a/cpp2rust/converter/rules/rule_keys.h b/cpp2rust/converter/rules/rule_keys.h
index 7056a51ed..6eec76ab3 100644
--- a/cpp2rust/converter/rules/rule_keys.h
+++ b/cpp2rust/converter/rules/rule_keys.h
@@ -39,6 +39,9 @@ using ExprKey = std::variant<Member, Constructor, Unqualified>;
 
 using TypeKey = std::variant<const clang::Decl *, const clang::Type *>;
 
+inline const TypeKey kAnyClass = static_cast<const clang::Decl *>(nullptr);
+inline const Constructor kAnyConstructor{nullptr};
+
 std::optional<ExprKey> GetExprKey(clang::ASTContext &ctx,
                                   const clang::Expr *use);
 
diff --git a/cpp2rust/converter/rules/rules_loader.cpp b/cpp2rust/converter/rules/rules_loader.cpp
index 73f5c1bfe..4ae9bd661 100644
--- a/cpp2rust/converter/rules/rules_loader.cpp
+++ b/cpp2rust/converter/rules/rules_loader.cpp
@@ -8,6 +8,7 @@
 #include <clang/Basic/LangOptions.h>
 #include <clang/Lex/Lexer.h>
 #include <clang/Lex/Preprocessor.h>
+#include <clang/Sema/Lookup.h>
 #include <clang/Sema/Sema.h>
 #include <llvm/ADT/DenseSet.h>
 #include <llvm/ADT/STLExtras.h>
@@ -203,6 +204,7 @@ class RuleUsageCollector
           AddTemplateArgs(spec->getTemplateArgs().asArray());
         }
         AddSpecialMembers(record);
+        AddIterator(type, record);
       }
       return;
     }
@@ -226,6 +228,46 @@ class RuleUsageCollector
     }
   }
 
+  void AddIterator(clang::QualType type, const clang::CXXRecordDecl *record) {
+    auto *std_namespace = sema_.getStdNamespace();
+    if (!std_namespace ||
+        !ctx_.getSourceManager().isInSystemHeader(record->getLocation())) {
+      return;
+    }
+    clang::ClassTemplateDecl *traits = nullptr;
+    for (auto *decl :
+         std_namespace->lookup(&ctx_.Idents.get("iterator_traits"))) {
+      if ((traits = llvm::dyn_cast<clang::ClassTemplateDecl>(decl))) {
+        break;
+      }
+    }
+    if (!traits) {
+      return;
+    }
+    auto loc = record->getLocation();
+    RuleDecls::Trial trial(sema_);
+    clang::TemplateArgumentListInfo args(loc, loc);
+    args.addArgument(
+        clang::TemplateArgumentLoc(clang::TemplateArgument(type),
+                                   ctx_.getTrivialTypeSourceInfo(type, loc)));
+    auto instance = sema_.CheckTemplateIdType(
+        clang::ElaboratedTypeKeyword::None, clang::TemplateName(traits), loc,
+        args, /*Scope=*/nullptr, /*ForNestedNameSpecifier=*/false);
+    if (instance.isNull() || !sema_.isCompleteType(loc, instance) ||
+        trial.failed()) {
+      return;
+    }
+    auto *instance_record = instance->getAsCXXRecordDecl();
+    if (!instance_record) {
+      return;
+    }
+    clang::LookupResult category(sema_, &ctx_.Idents.get("iterator_category"),
+                                 loc, clang::Sema::LookupMemberName);
+    if (sema_.LookupQualifiedName(category, instance_record)) {
+      AddKey(kAnyIteratorKey);
+    }
+  }
+
   void AddTemplateArgs(llvm::ArrayRef<clang::TemplateArgument> args) {
     for (const auto &arg : args) {
       switch (arg.getKind()) {
@@ -310,7 +352,9 @@ std::string BuildRulesEpilogue(const std::unordered_set<std::string> &keys,
     out += "namespace cpp2rust_rules {\n" + common->str() + "}\n";
   }
   auto rules = index.getObject("rules");
-  for (const auto &key : keys) {
+  std::vector<std::string> candidates(keys.begin(), keys.end());
+  candidates.push_back(kAnyClassKey);
+  for (const auto &key : candidates) {
     auto entries = rules->getArray(key);
     if (!entries) {
       continue;
diff --git a/cpp2rust/converter/rules/rules_loader.h b/cpp2rust/converter/rules/rules_loader.h
index 52919d519..75dbf6915 100644
--- a/cpp2rust/converter/rules/rules_loader.h
+++ b/cpp2rust/converter/rules/rules_loader.h
@@ -19,6 +19,10 @@ namespace cpp2rust::RulesLoader {
 
 inline constexpr const char *kPragmaName = "cpp2rust_rules";
 
+inline constexpr const char *kAnyClassKey = "*";
+
+inline constexpr const char *kAnyIteratorKey = "std/iterator_traits";
+
 std::string ClassKey(const clang::NamedDecl *decl);
 
 std::string MemberName(clang::DeclarationName name);
diff --git a/cpp2rust/rule_preprocessing/cpp_rule_indexer.cpp b/cpp2rust/rule_preprocessing/cpp_rule_indexer.cpp
index 2478d6f2c..122f19d04 100644
--- a/cpp2rust/rule_preprocessing/cpp_rule_indexer.cpp
+++ b/cpp2rust/rule_preprocessing/cpp_rule_indexer.cpp
@@ -26,7 +26,6 @@
 #include <vector>
 
 #include "compat/platform_flags.h"
-#include "converter/rules/decls.h"
 #include "converter/rules/rules_loader.h"
 
 namespace fs = std::filesystem;
@@ -134,11 +133,6 @@ std::string ClassOfParameters(const clang::Decl *rule) {
   return {};
 }
 
-std::string ClassOfEnableIf(const clang::Decl *rule) {
-  auto same = RuleDecls::EnableIfSameType(rule);
-  return same.isNull() ? std::string() : ClassOf(same);
-}
-
 const clang::Expr *RuleExpr(const clang::Decl *decl) {
   if (auto var = llvm::dyn_cast<clang::VarDecl>(decl)) {
     return var->getInit();
@@ -266,8 +260,9 @@ void IndexRuleFile(clang::ASTContext &ctx, const std::string &dir_name,
     if (key.empty()) {
       key = ClassOfParameters(decl);
     }
-    if (key.empty()) {
-      key = ClassOfEnableIf(decl);
+    bool any_class = key.empty() && llvm::isa<clang::TemplateDecl>(decl);
+    if (any_class) {
+      key = RulesLoader::kAnyClassKey;
     }
     if (key.empty()) {
       llvm::errs() << "ERROR: cannot derive the key of rule '" << name
@@ -277,7 +272,10 @@ void IndexRuleFile(clang::ASTContext &ctx, const std::string &dir_name,
     auto range = clang::tooling::getExtendedRange(*decl, clang::tok::semi, ctx);
     auto text = clang::tooling::getText(range, ctx).str() + '\n';
     llvm::json::Object rule{{"dir", dir_name}, {"name", name}, {"text", text}};
-    if (auto required = RequiredClasses(decl, alias); !required.empty()) {
+    if (any_class) {
+      rule["requires"] = llvm::json::Array{RulesLoader::kAnyIteratorKey};
+    } else if (auto required = RequiredClasses(decl, alias);
+               !required.empty()) {
       rule["requires"] = llvm::json::Array(required);
     }
     AddRule(rules, key, std::move(rule));
diff --git a/libcc2rs/src/iterators.rs b/libcc2rs/src/iterators.rs
index 58fb7a6da..81e42da7e 100644
--- a/libcc2rs/src/iterators.rs
+++ b/libcc2rs/src/iterators.rs
@@ -1,215 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use crate::{AsPointer, CChar, PostfixDec, PostfixInc, PrefixDec, PrefixInc, Ptr, Value};
-use std::collections::BTreeMap;
-use std::ops::Bound;
-
-pub trait MapAccess: Clone + Default {
-    type Key: Ord + Clone;
-    type Value;
-    fn with<R>(&self, f: impl FnOnce(&BTreeMap<Self::Key, Self::Value>) -> R) -> R;
-    fn with_mut<R>(&self, f: impl FnOnce(&mut BTreeMap<Self::Key, Self::Value>) -> R) -> R;
-}
-
-impl<K: Ord + Clone + 'static, V: 'static> MapAccess for Ptr<BTreeMap<K, V>> {
-    type Key = K;
-    type Value = V;
-
-    fn with<R>(&self, f: impl FnOnce(&BTreeMap<K, V>) -> R) -> R {
-        Ptr::with(self, f)
-    }
-
-    fn with_mut<R>(&self, f: impl FnOnce(&mut BTreeMap<K, V>) -> R) -> R {
-        Ptr::with_mut(self, f)
-    }
-}
-
-impl<K: Ord + Clone, V> MapAccess for *const BTreeMap<K, V> {
-    type Key = K;
-    type Value = V;
-
-    fn with<R>(&self, f: impl FnOnce(&BTreeMap<K, V>) -> R) -> R {
-        unsafe { f(&**self) }
-    }
-
-    fn with_mut<R>(&self, f: impl FnOnce(&mut BTreeMap<K, V>) -> R) -> R {
-        unsafe { f(&mut *(*self as *mut BTreeMap<K, V>)) }
-    }
-}
-
-pub struct MapIter<K, MapRef> {
-    map: MapRef,
-    key: Option<K>,
-}
-
-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 {
-        Self {
-            map: self.map.clone(),
-            key: self.key.clone(),
-        }
-    }
-}
-
-impl<K: PartialEq, MapRef> PartialEq for MapIter<K, MapRef> {
-    fn eq(&self, other: &Self) -> bool {
-        self.key == other.key
-    }
-}
-
-impl<K: Ord + Clone, MapRef: MapAccess<Key = K>> MapIter<K, MapRef> {
-    pub fn null() -> Self {
-        Self {
-            map: Default::default(),
-            key: None,
-        }
-    }
-
-    pub fn begin(map: MapRef) -> Self {
-        let first_key = map.with(|m| m.keys().next().cloned());
-        Self {
-            map,
-            key: first_key,
-        }
-    }
-
-    pub fn end(map: MapRef) -> Self {
-        Self { map, key: None }
-    }
-
-    pub fn find_key(map: MapRef, key: &K) -> Self {
-        if map.with(|m| m.contains_key(key)) {
-            Self {
-                map,
-                key: Some(key.clone()),
-            }
-        } else {
-            Self::end(map)
-        }
-    }
-
-    pub fn is_end(&self) -> bool {
-        self.key.is_none()
-    }
-
-    pub fn key(&self) -> &Option<K> {
-        &self.key
-    }
-
-    pub fn inc(&mut self) {
-        self.key = match &self.key {
-            Some(k) => self.map.with(|map| {
-                map.range((Bound::Excluded(k), Bound::Unbounded))
-                    .next()
-                    .map(|(k, _)| k.clone())
-            }),
-            None => panic!("ub: increment past end"),
-        };
-    }
-
-    pub fn dec(&mut self) {
-        self.key = match &self.key {
-            Some(k) => self.map.with(|map| {
-                map.range((Bound::Unbounded, Bound::Excluded(k)))
-                    .next_back()
-                    .map(|(k, _)| k.clone())
-            }),
-            None => self.map.with(|map| map.keys().next_back().cloned()),
-        };
-    }
-
-    pub fn erase(map: MapRef, iter: &Self) -> Self {
-        let key = iter
-            .key
-            .as_ref()
-            .expect("ub: erase of end iterator")
-            .clone();
-        let next_key = map.with(|m| {
-            m.range((Bound::Excluded(&key), Bound::Unbounded))
-                .next()
-                .map(|(k, _)| k.clone())
-        });
-        map.with_mut(|m| m.remove(&key));
-        Self { map, key: next_key }
-    }
-}
-
-pub trait MapIterator {
-    type Entry;
-    fn deref(&self) -> Self::Entry;
-}
-
-impl<K: Ord + Clone + 'static, V: 'static> MapIterator for RefcountMapIter<K, V> {
-    type Entry = Ptr<(Value<K>, 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").as_pointer())
-    }
-}
-
-impl<K: Ord + Clone, V> MapIterator for UnsafeMapIterator<K, V> {
-    type Entry = *mut (K, V);
-
-    fn deref(&self) -> *mut (K, V) {
-        unsafe {
-            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 (K, V)
-        }
-    }
-}
-
-impl<K: Ord + Clone, MapRef: MapAccess<Key = K>> Iterator for MapIter<K, MapRef> {
-    type Item = Self;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.is_end() {
-            return None;
-        }
-        let snapshot = self.clone();
-        self.inc();
-        Some(snapshot)
-    }
-}
-
-impl<K: Ord + Clone, MapRef: MapAccess<Key = K>> PrefixInc for MapIter<K, MapRef> {
-    fn prefix_inc(&mut self) -> Self {
-        self.inc();
-        self.clone()
-    }
-}
-
-impl<K: Ord + Clone, MapRef: MapAccess<Key = K>> PostfixInc for MapIter<K, MapRef> {
-    fn postfix_inc(&mut self) -> Self {
-        let ret = self.clone();
-        self.inc();
-        ret
-    }
-}
-
-impl<K: Ord + Clone, MapRef: MapAccess<Key = K>> PrefixDec for MapIter<K, MapRef> {
-    fn prefix_dec(&mut self) -> Self {
-        self.dec();
-        self.clone()
-    }
-}
-
-impl<K: Ord + Clone, MapRef: MapAccess<Key = K>> PostfixDec for MapIter<K, MapRef> {
-    fn postfix_dec(&mut self) -> Self {
-        let ret = self.clone();
-        self.dec();
-        ret
-    }
-}
+use crate::{CChar, Ptr};
 
 pub struct CStringIterator<T: CChar = u8> {
     pub(crate) ptr: Ptr<T>,
diff --git a/rules/algorithm/src.cpp b/rules/algorithm/src.cpp
index 40b020c3f..bfed13eaa 100644
--- a/rules/algorithm/src.cpp
+++ b/rules/algorithm/src.cpp
@@ -9,8 +9,6 @@
 #include <type_traits>
 #include <vector>
 
-#include "../common/traits.h"
-
 template <typename T1> void f1(T1 first, T1 last) {
   return std::sort(first, last);
 }
@@ -27,24 +25,19 @@ template <typename T1, typename T2> void f6(T1 first, T1 last, T2 comp) {
   return std::stable_sort(first, last, comp);
 }
 
-template <typename T1> T1 *f8(T1 *first, T1 *last) {
+template <typename T1> T1 f8(T1 first, T1 last) {
   return std::max_element(first, last);
 }
 
 template <typename T1> void f9(T1 &a0, T1 &a1) { return std::swap(a0, a1); }
 
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-typename std::vector<T1, T2>::iterator f10(It a0, It a1) {
-  return std::unique(a0, a1);
+template <typename T1> T1 f10(T1 first, T1 last) {
+  return std::unique(first, last);
 }
 
-template <typename It, typename T2, typename T1 = ValueOf<It>,
-          typename T3 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T3>::iterator>>
-void f12(It a0, It a1, const T2 &a2) {
-  return std::fill(a0, a1, a2);
+template <typename T1, typename T2>
+void f12(T1 first, T1 last, const T2 &value) {
+  return std::fill(first, last, value);
 }
 
 std::ostream_iterator<char> f13(std::string::iterator a0,
diff --git a/rules/algorithm/tgt_refcount.rs b/rules/algorithm/tgt_refcount.rs
index 52a96393e..d177de743 100644
--- a/rules/algorithm/tgt_refcount.rs
+++ b/rules/algorithm/tgt_refcount.rs
@@ -6,55 +6,86 @@ use std::cell::RefCell;
 use std::io::Write;
 use std::rc::Rc;
 
-fn f1<T1: Ord + 'static>(a0: Ptr<T1>, a1: Ptr<T1>) {
-    a0.sort(a1.get_offset())
+fn f1<T1: CppRandomAccessIterator<T2>, T2: Ord + Clone + ByteRepr>(a0: T1, a1: T1) {
+    let __n = a1.iter_distance(&a0);
+    let mut __order: Vec<isize> = (0..__n).collect();
+    __order.sort_by(|&__x, &__y| {
+        a0.iter_at(__x)
+            .with(|__a| a0.iter_at(__y).with(|__b| __a.cmp(__b)))
+    });
+    let __values: Vec<_> = __order.iter().map(|&__i| a0.iter_at(__i).read()).collect();
+    for (__i, __v) in (0..__n).zip(__values) {
+        a0.iter_at(__i).write(__v);
+    }
 }
 
-fn f2<T1: Clone + PartialOrd + ByteRepr, T2: Clone + From<T1> + ByteRepr>(
-    a0: Ptr<T1>,
-    a1: Ptr<T1>,
-    a2: Ptr<T2>,
-) -> Ptr<T2> {
-    let count = a1.get_offset() - a0.get_offset();
-    let mut outptr = a2;
-    for value in PtrValueIter::new(&a0, count) {
-        outptr.write(value.into());
-        outptr += 1;
+fn f2<
+    T1: CppInputIterator<T3>,
+    T2: CppIterator<T4>,
+    T3: Clone + ByteRepr,
+    T4: From<T3> + ByteRepr,
+>(
+    a0: T1,
+    a1: T1,
+    a2: T2,
+) -> T2 {
+    let mut __first = a0;
+    let mut __out = a2;
+    while __first != a1 {
+        __out.iter_deref().write(__first.iter_deref().read().into());
+        __first.iter_inc();
+        __out.iter_inc();
     }
-    outptr
+    __out
 }
 
-fn f3<T1: PartialEq + Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>, a2: T1) -> Ptr<T1> {
-    let count = (a1.get_offset() - a0.get_offset()) as usize;
-    a0.offset(
-        a0.clone()
-            .into_iter()
-            .take(count)
-            .position(|value_0| value_0.read() == a2)
-            .unwrap_or(count) as isize,
-    )
+fn f3<T1: CppInputIterator<T3>, T2, T3: PartialEq<T2> + ByteRepr>(a0: T1, a1: T1, a2: T2) -> T1 {
+    let mut __it = a0;
+    while __it != a1 && __it.iter_deref().with(|__v| *__v != a2) {
+        __it.iter_inc();
+    }
+    __it
 }
 
-fn f6<T1: Ord + Clone + 'static, T2>(a0: Ptr<T1>, a1: Ptr<T1>, a2: T2)
+fn f6<T1: CppRandomAccessIterator<T3>, T2, T3: Clone + ByteRepr>(a0: T1, a1: T1, a2: T2)
 where
-    T2: Callable2<Ptr<T1>, Ptr<T1>, bool>,
+    T2: Callable2<Ptr<T3>, Ptr<T3>, bool>,
 {
-    a0.sort_with_cmp(a1.get_offset(), |x, y| a2.call(x, y))
+    let __n = a1.iter_distance(&a0);
+    let mut __order: Vec<isize> = (0..__n).collect();
+    __order.sort_by(|&__x, &__y| {
+        let __a = a0.iter_at(__x);
+        let __b = a0.iter_at(__y);
+        if a2.call(__a.clone(), __b.clone()) {
+            std::cmp::Ordering::Less
+        } else if a2.call(__b, __a) {
+            std::cmp::Ordering::Greater
+        } else {
+            std::cmp::Ordering::Equal
+        }
+    });
+    let __values: Vec<_> = __order.iter().map(|&__i| a0.iter_at(__i).read()).collect();
+    for (__i, __v) in (0..__n).zip(__values) {
+        a0.iter_at(__i).write(__v);
+    }
 }
 
-fn f8<T1: PartialOrd + Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) -> Ptr<T1> {
-    let count = a1.get_offset() - a0.get_offset();
-    let max_index = PtrValueIter::new(&a0, count)
-        .enumerate()
-        .max_by(|(idx_a, val_a), (idx_b, val_b)| {
-            val_a
-                .partial_cmp(val_b)
-                .unwrap_or(std::cmp::Ordering::Equal)
-                .then_with(|| idx_b.cmp(idx_a))
-        })
-        .map(|(idx, _)| idx)
-        .unwrap_or(0);
-    a0 + max_index
+fn f8<T1: CppInputIterator<T2>, T2: PartialOrd + ByteRepr>(a0: T1, a1: T1) -> T1 {
+    let mut __best = a0.clone();
+    if a0 != a1 {
+        let mut __it = a0;
+        __it.iter_inc();
+        while __it != a1 {
+            if __best
+                .iter_deref()
+                .with(|__b| __it.iter_deref().with(|__v| __b < __v))
+            {
+                __best = __it.clone();
+            }
+            __it.iter_inc();
+        }
+    }
+    __best
 }
 
 fn f9<T1: Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) {
@@ -63,35 +94,31 @@ fn f9<T1: Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) {
     a1.write(tmp);
 }
 
-fn f10<T1: PartialEq + Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) -> Ptr<T1> {
-    let count = a1.get_offset() - a0.get_offset();
-    if count <= 1 {
+fn f10<T1: CppInputIterator<T2>, T2: PartialEq + Clone + ByteRepr>(a0: T1, a1: T1) -> T1 {
+    if a0 == a1 {
         a1
     } else {
-        let mut iter = PtrValueIter::new(&a0, count);
-        let mut write_ptr = a0;
-        let mut last_unique = iter.next().unwrap();
-
-        // the first unique value is already in place
-        write_ptr += 1;
-
-        for current_val in iter {
-            if current_val != last_unique {
-                write_ptr.write(current_val.clone());
-                last_unique = current_val;
-                write_ptr += 1;
+        let mut __write = a0.clone();
+        let mut __it = a0;
+        __it.iter_inc();
+        while __it != a1 {
+            let __v = __it.iter_deref().read();
+            if __write.iter_deref().with(|__w| *__w != __v) {
+                __write.iter_inc();
+                __write.iter_deref().write(__v);
             }
+            __it.iter_inc();
         }
-        write_ptr
+        __write.iter_inc();
+        __write
     }
 }
 
-fn f12<T1: Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>, a2: T1) {
-    let mut __a0 = a0;
-    while __a0 != a1 {
-        let v = a2.clone();
-        __a0.write(v);
-        __a0 += 1;
+fn f12<T1: CppInputIterator<T2>, T2: Clone + ByteRepr>(a0: T1, a1: T1, a2: T2) {
+    let mut __it = a0;
+    while __it != a1 {
+        __it.iter_deref().write(Clone::clone(&a2));
+        __it.iter_inc();
     }
 }
 
diff --git a/rules/algorithm/tgt_unsafe.rs b/rules/algorithm/tgt_unsafe.rs
index 6257589a5..9078e4165 100644
--- a/rules/algorithm/tgt_unsafe.rs
+++ b/rules/algorithm/tgt_unsafe.rs
@@ -4,90 +4,112 @@
 use libcc2rs::*;
 use std::io::{Seek, Write};
 
-unsafe fn f1<T1: Ord>(a0: *mut T1, a1: *mut T1) {
-    let len = a1.offset_from(a0) as usize;
-    ::std::slice::from_raw_parts_mut(a0, len).sort()
+unsafe fn f1<T1: UnsafeCppRandomAccessIterator<T2>, T2: Ord>(a0: T1, a1: T1) {
+    let __n = a1.iter_distance(&a0);
+    let mut __order: Vec<isize> = (0..__n).collect();
+    __order.sort_by(|&__x, &__y| (*a0.iter_at(__x)).cmp(&*a0.iter_at(__y)));
+    let __values: Vec<_> = __order
+        .iter()
+        .map(|&__i| std::ptr::read(a0.iter_at(__i)))
+        .collect();
+    for (__i, __v) in (0..__n).zip(__values) {
+        std::ptr::write(a0.iter_at(__i), __v);
+    }
 }
 
-unsafe fn f2<T1: Clone, T2: From<T1>>(a0: *const T1, a1: *const T1, a2: *mut T2) -> *mut T2 {
-    let mut outptr = a2.clone();
-    let mut curr = a0.clone();
-    while curr < a1 {
-        *outptr = (*curr).clone().into();
-        curr = curr.offset(1);
-        outptr = outptr.offset(1);
+unsafe fn f2<T1: UnsafeCppInputIterator<T3>, T2: UnsafeCppIterator<T4>, T3: Clone, T4: From<T3>>(
+    a0: T1,
+    a1: T1,
+    a2: T2,
+) -> T2 {
+    let mut __first = a0;
+    let mut __out = a2;
+    while __first != a1 {
+        *__out.iter_deref() = (*__first.iter_deref()).clone().into();
+        __first.iter_inc();
+        __out.iter_inc();
     }
-    outptr
+    __out
 }
 
-unsafe fn f3<T1: PartialEq>(a0: *mut T1, a1: *mut T1, a2: T1) -> *mut T1 {
-    let mut it = a0;
-    while it != a1 && *it != a2 {
-        it = it.add(1);
+unsafe fn f3<T1: UnsafeCppInputIterator<T3>, T2, T3: PartialEq<T2>>(a0: T1, a1: T1, a2: T2) -> T1 {
+    let mut __it = a0;
+    while __it != a1 && *__it.iter_deref() != a2 {
+        __it.iter_inc();
     }
-    it
+    __it
 }
 
-unsafe fn f6<T1: Ord, T2>(a0: *mut T1, a1: *mut T1, a2: T2)
+unsafe fn f6<T1: UnsafeCppRandomAccessIterator<T3>, T2, T3>(a0: T1, a1: T1, a2: T2)
 where
-    T2: Callable2<*const T1, *const T1, bool>,
+    T2: Callable2<*const T3, *const T3, bool>,
 {
-    let len = a1.offset_from(a0) as usize;
-    ::std::slice::from_raw_parts_mut(a0, len).sort_by(|x, y| {
-        if a2.call(x as *const _, y as *const _) {
+    let __n = a1.iter_distance(&a0);
+    let mut __order: Vec<isize> = (0..__n).collect();
+    __order.sort_by(|&__x, &__y| {
+        let __a = a0.iter_at(__x) as *const _;
+        let __b = a0.iter_at(__y) as *const _;
+        if a2.call(__a, __b) {
             std::cmp::Ordering::Less
-        } else if a2.call(y as *const _, x as *const _) {
+        } else if a2.call(__b, __a) {
             std::cmp::Ordering::Greater
         } else {
             std::cmp::Ordering::Equal
         }
-    })
+    });
+    let __values: Vec<_> = __order
+        .iter()
+        .map(|&__i| std::ptr::read(a0.iter_at(__i)))
+        .collect();
+    for (__i, __v) in (0..__n).zip(__values) {
+        std::ptr::write(a0.iter_at(__i), __v);
+    }
 }
 
-unsafe fn f8<T1: PartialOrd>(a0: *mut T1, a1: *mut T1) -> *mut T1 {
-    let count = a1.offset_from(a0) as usize;
-    std::slice::from_raw_parts(a0, count)
-        .iter()
-        .enumerate()
-        .max_by(|(idx_a, x), (idx_b, y)| {
-            x.partial_cmp(y)
-                .unwrap_or(std::cmp::Ordering::Equal)
-                .then_with(|| idx_b.cmp(idx_a))
-        })
-        .map(|(i, _)| a0.add(i))
-        .unwrap_or(a0)
+unsafe fn f8<T1: UnsafeCppInputIterator<T2>, T2: PartialOrd>(a0: T1, a1: T1) -> T1 {
+    let mut __best = a0.clone();
+    if a0 != a1 {
+        let mut __it = a0;
+        __it.iter_inc();
+        while __it != a1 {
+            if *__best.iter_deref() < *__it.iter_deref() {
+                __best = __it.clone();
+            }
+            __it.iter_inc();
+        }
+    }
+    __best
 }
 
 unsafe fn f9<T1>(a0: &mut T1, a1: &mut T1) {
     std::mem::swap(&mut *a0, &mut *a1)
 }
 
-unsafe fn f10<T1: PartialOrd + Clone>(a0: *mut T1, a1: *mut T1) -> *mut T1 {
+unsafe fn f10<T1: UnsafeCppInputIterator<T2>, T2: PartialEq + Clone>(a0: T1, a1: T1) -> T1 {
     if a0 == a1 {
-        a0
+        a1
     } else {
-        let mut write = a0;
-        let mut prev = a0;
-        let mut it = a0;
-        it = it.add(1);
-
-        while it != a1 {
-            if *prev != *it {
-                write = write.add(1);
-                *write = (*it).clone();
-                prev = write;
+        let mut __write = a0.clone();
+        let mut __it = a0;
+        __it.iter_inc();
+        while __it != a1 {
+            if *__write.iter_deref() != *__it.iter_deref() {
+                __write.iter_inc();
+                *__write.iter_deref() = (*__it.iter_deref()).clone();
             }
-            it = it.add(1);
+            __it.iter_inc();
         }
-
-        write = write.add(1);
-        write
+        __write.iter_inc();
+        __write
     }
 }
 
-unsafe fn f12<T1: Clone>(a0: *mut T1, a1: *mut T1, a2: T1) {
-    let count = a1.offset_from(a0) as usize;
-    std::slice::from_raw_parts_mut(a0, count).fill(a2)
+unsafe fn f12<T1: UnsafeCppInputIterator<T2>, T2: Clone>(a0: T1, a1: T1, a2: T2) {
+    let mut __it = a0;
+    while __it != a1 {
+        *__it.iter_deref() = Clone::clone(&a2);
+        __it.iter_inc();
+    }
 }
 
 unsafe fn f13(
diff --git a/rules/common/traits.h b/rules/common/traits.h
deleted file mode 100644
index 6e50a69e8..000000000
--- a/rules/common/traits.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2022-present INESC-ID.
-// Distributed under the MIT license that can be found in the LICENSE file.
-
-template <bool B, typename T = void> struct EnableIf {};
-
-template <typename T> struct EnableIf<true, T> {
-  using type = T;
-};
-
-template <typename A, typename B> struct IsSame {
-  static constexpr bool value = false;
-};
-
-template <typename T> struct IsSame<T, T> {
-  static constexpr bool value = true;
-};
-
-template <typename T> struct RemoveConst {
-  using type = T;
-};
-
-template <typename T> struct RemoveConst<const T> {
-  using type = T;
-};
-
-template <typename T, typename D, typename... Args> struct FindAlloc {
-  using type = D;
-};
-
-template <typename T, typename D, template <typename, typename> class C,
-          typename A, typename... Args>
-struct FindAlloc<T, D, C<T, A>, Args...> {
-  using type = A;
-};
-
-template <typename T, typename D, typename Arg, typename... Args>
-struct FindAlloc<T, D, Arg, Args...> : FindAlloc<T, D, Args...> {};
-
-template <typename It, typename T, typename D> struct AllocOf {
-  using type = D;
-};
-
-template <template <typename...> class I, typename... Args, typename T,
-          typename D>
-struct AllocOf<I<Args...>, T, D> : FindAlloc<T, D, Args...> {};
-
-template <typename It, typename T>
-using SameAs = typename EnableIf<IsSame<It, T>::value>::type;
-
-template <typename It> using ValueOf = typename It::value_type;
-
-template <typename It>
-using KeyOf = typename RemoveConst<typename It::value_type::first_type>::type;
-
-template <typename It> using MappedOf = typename It::value_type::second_type;
-
-template <typename It, typename D>
-using AllocatorOf = typename AllocOf<It, ValueOf<It>, D>::type;
diff --git a/rules/cstddef/src.c b/rules/cstddef/src.c
index d1072119e..c3d250b66 100644
--- a/rules/cstddef/src.c
+++ b/rules/cstddef/src.c
@@ -5,5 +5,6 @@
 #include <sys/types.h>
 
 typedef size_t t2;
+typedef ptrdiff_t t3;
 typedef __typeof__(sizeof(0)) t5;
 typedef ssize_t t6;
diff --git a/rules/cstddef/src.cpp b/rules/cstddef/src.cpp
index 84248e58c..400acd122 100644
--- a/rules/cstddef/src.cpp
+++ b/rules/cstddef/src.cpp
@@ -3,4 +3,6 @@
 
 #include <cstddef>
 
+typedef std::ptrdiff_t t4;
+
 typedef std::size_t t9;
diff --git a/rules/cstddef/tgt_unsafe.rs b/rules/cstddef/tgt_unsafe.rs
index 5624be759..573487aaa 100644
--- a/rules/cstddef/tgt_unsafe.rs
+++ b/rules/cstddef/tgt_unsafe.rs
@@ -9,6 +9,14 @@ fn t2() -> usize {
     0_usize
 }
 
+fn t3() -> isize {
+    0_isize
+}
+
+fn t4() -> isize {
+    0_isize
+}
+
 fn t5() -> usize {
     0_usize
 }
diff --git a/rules/iterator_category/shim.rs b/rules/iterator_category/shim.rs
new file mode 100644
index 000000000..3994c5093
--- /dev/null
+++ b/rules/iterator_category/shim.rs
@@ -0,0 +1,453 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use std::cmp::Ordering;
+use std::convert::Infallible;
+use std::marker::PhantomData;
+
+use std::rc::Rc;
+
+use crate::{MapNode, PostfixDec, PostfixInc, PrefixDec, PrefixInc, Ptr, UnsafeMapNode, Value};
+
+pub trait CppIterator<T>: Clone {
+    fn iter_deref(&self) -> Ptr<T>;
+    fn iter_inc(&mut self) -> Self;
+    fn iter_post_inc(&mut self) -> Self;
+}
+
+pub trait CppInputIterator<T>: CppIterator<T> + PartialEq {}
+
+pub trait CppBidirectionalIterator<T>: CppInputIterator<T> {
+    fn iter_dec(&mut self) -> Self;
+    fn iter_post_dec(&mut self) -> Self;
+}
+
+pub trait CppRandomAccessIterator<T>: CppBidirectionalIterator<T> + PartialOrd {
+    fn iter_add(&self, n: isize) -> Self;
+    fn iter_add_assign(&mut self, n: isize) -> Self;
+    fn iter_distance(&self, from: &Self) -> isize;
+    fn iter_at(&self, n: isize) -> Ptr<T>;
+}
+
+pub trait UnsafeCppIterator<T>: Clone {
+    fn iter_deref(&self) -> *mut T;
+    fn iter_inc(&mut self) -> Self;
+    fn iter_post_inc(&mut self) -> Self;
+}
+
+pub trait UnsafeCppInputIterator<T>: UnsafeCppIterator<T> + PartialEq {}
+
+pub trait UnsafeCppBidirectionalIterator<T>: UnsafeCppInputIterator<T> {
+    fn iter_dec(&mut self) -> Self;
+    fn iter_post_dec(&mut self) -> Self;
+}
+
+pub trait UnsafeCppRandomAccessIterator<T>:
+    UnsafeCppBidirectionalIterator<T> + PartialOrd
+{
+    fn iter_add(&self, n: isize) -> Self;
+    fn iter_add_assign(&mut self, n: isize) -> Self;
+    fn iter_distance(&self, from: &Self) -> isize;
+    fn iter_at(&self, n: isize) -> *mut T;
+}
+
+impl<T> CppIterator<T> for Ptr<T> {
+    fn iter_deref(&self) -> Ptr<T> {
+        self.clone()
+    }
+    fn iter_inc(&mut self) -> Self {
+        PrefixInc::prefix_inc(self)
+    }
+    fn iter_post_inc(&mut self) -> Self {
+        PostfixInc::postfix_inc(self)
+    }
+}
+
+impl<T> CppInputIterator<T> for Ptr<T> {}
+
+impl<T> CppBidirectionalIterator<T> for Ptr<T> {
+    fn iter_dec(&mut self) -> Self {
+        PrefixDec::prefix_dec(self)
+    }
+    fn iter_post_dec(&mut self) -> Self {
+        PostfixDec::postfix_dec(self)
+    }
+}
+
+impl<T> CppRandomAccessIterator<T> for Ptr<T> {
+    fn iter_add(&self, n: isize) -> Self {
+        self.offset(n)
+    }
+    fn iter_add_assign(&mut self, n: isize) -> Self {
+        *self = self.offset(n);
+        self.clone()
+    }
+    fn iter_distance(&self, from: &Self) -> isize {
+        self.get_offset() as isize - from.get_offset() as isize
+    }
+    fn iter_at(&self, n: isize) -> Ptr<T> {
+        self.offset(n)
+    }
+}
+
+macro_rules! raw_pointer_iterator {
+    ($ptr:ty, $deref:expr) => {
+        impl<T> UnsafeCppIterator<T> for $ptr {
+            fn iter_deref(&self) -> *mut T {
+                $deref(*self)
+            }
+            fn iter_inc(&mut self) -> Self {
+                *self = self.wrapping_add(1);
+                *self
+            }
+            fn iter_post_inc(&mut self) -> Self {
+                let old = *self;
+                *self = self.wrapping_add(1);
+                old
+            }
+        }
+
+        impl<T> UnsafeCppInputIterator<T> for $ptr {}
+
+        impl<T> UnsafeCppBidirectionalIterator<T> for $ptr {
+            fn iter_dec(&mut self) -> Self {
+                *self = self.wrapping_sub(1);
+                *self
+            }
+            fn iter_post_dec(&mut self) -> Self {
+                let old = *self;
+                *self = self.wrapping_sub(1);
+                old
+            }
+        }
+
+        impl<T> UnsafeCppRandomAccessIterator<T> for $ptr {
+            fn iter_add(&self, n: isize) -> Self {
+                self.wrapping_offset(n)
+            }
+            fn iter_add_assign(&mut self, n: isize) -> Self {
+                *self = self.wrapping_offset(n);
+                *self
+            }
+            fn iter_distance(&self, from: &Self) -> isize {
+                unsafe { self.offset_from(*from) }
+            }
+            fn iter_at(&self, n: isize) -> *mut T {
+                $deref(self.wrapping_offset(n))
+            }
+        }
+    };
+}
+
+raw_pointer_iterator!(*mut T, |p: *mut T| p);
+raw_pointer_iterator!(*const T, |p: *const T| p.cast_mut());
+
+macro_rules! uninhabited_iterator {
+    ($name:ident, $what:literal) => {
+        pub enum $name<T> {
+            #[doc(hidden)]
+            None(Infallible, PhantomData<T>),
+        }
+
+        impl<T> $name<T> {
+            pub fn uninitialized() -> Self {
+                panic!(concat!("no container provides ", $what, " yet"))
+            }
+
+            fn never(&self) -> ! {
+                match self {
+                    Self::None(never, _) => match *never {},
+                }
+            }
+        }
+
+        impl<T> Clone for $name<T> {
+            fn clone(&self) -> Self {
+                self.never()
+            }
+        }
+
+        impl<T> PartialEq for $name<T> {
+            fn eq(&self, _: &Self) -> bool {
+                self.never()
+            }
+        }
+    };
+}
+
+macro_rules! uninhabited_iterator_ops {
+    ($name:ident, $iter:ident, $ptr:ty) => {
+        impl<T> $iter<T> for $name<T> {
+            fn iter_deref(&self) -> $ptr {
+                self.never()
+            }
+            fn iter_inc(&mut self) -> Self {
+                self.never()
+            }
+            fn iter_post_inc(&mut self) -> Self {
+                self.never()
+            }
+        }
+    };
+}
+
+uninhabited_iterator!(InputIterator, "input iterators");
+uninhabited_iterator!(OutputIterator, "output iterators");
+uninhabited_iterator!(ForwardIterator, "forward iterators");
+uninhabited_iterator!(UnsafeInputIterator, "input iterators");
+uninhabited_iterator!(UnsafeOutputIterator, "output iterators");
+uninhabited_iterator!(UnsafeForwardIterator, "forward iterators");
+
+uninhabited_iterator_ops!(InputIterator, CppIterator, Ptr<T>);
+uninhabited_iterator_ops!(OutputIterator, CppIterator, Ptr<T>);
+uninhabited_iterator_ops!(ForwardIterator, CppIterator, Ptr<T>);
+uninhabited_iterator_ops!(UnsafeInputIterator, UnsafeCppIterator, *mut T);
+uninhabited_iterator_ops!(UnsafeOutputIterator, UnsafeCppIterator, *mut T);
+uninhabited_iterator_ops!(UnsafeForwardIterator, UnsafeCppIterator, *mut T);
+
+impl<T> CppInputIterator<T> for InputIterator<T> {}
+impl<T> CppInputIterator<T> for ForwardIterator<T> {}
+impl<T> UnsafeCppInputIterator<T> for UnsafeInputIterator<T> {}
+impl<T> UnsafeCppInputIterator<T> for UnsafeForwardIterator<T> {}
+
+pub enum BidirectionalIterator<T> {
+    Map(Value<MapNode<T>>),
+}
+
+impl<T> Default for BidirectionalIterator<T> {
+    fn default() -> Self {
+        Self::Map(MapNode::header())
+    }
+}
+
+impl<T> Clone for BidirectionalIterator<T> {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Map(node) => Self::Map(node.clone()),
+        }
+    }
+}
+
+impl<T> PartialEq for BidirectionalIterator<T> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Map(a), Self::Map(b)) => Rc::ptr_eq(a, b),
+        }
+    }
+}
+
+impl<T> CppIterator<T> for BidirectionalIterator<T> {
+    fn iter_deref(&self) -> Ptr<T> {
+        match self {
+            Self::Map(node) => MapNode::value(node),
+        }
+    }
+    fn iter_inc(&mut self) -> Self {
+        match self {
+            Self::Map(node) => *node = MapNode::next(node),
+        }
+        self.clone()
+    }
+    fn iter_post_inc(&mut self) -> Self {
+        let old = self.clone();
+        self.iter_inc();
+        old
+    }
+}
+
+impl<T> CppInputIterator<T> for BidirectionalIterator<T> {}
+
+impl<T> CppBidirectionalIterator<T> for BidirectionalIterator<T> {
+    fn iter_dec(&mut self) -> Self {
+        match self {
+            Self::Map(node) => *node = MapNode::prev(node),
+        }
+        self.clone()
+    }
+    fn iter_post_dec(&mut self) -> Self {
+        let old = self.clone();
+        self.iter_dec();
+        old
+    }
+}
+
+pub enum UnsafeBidirectionalIterator<T> {
+    Map(*mut UnsafeMapNode<T>),
+}
+
+impl<T> Default for UnsafeBidirectionalIterator<T> {
+    fn default() -> Self {
+        Self::Map(std::ptr::null_mut())
+    }
+}
+
+impl<T> Clone for UnsafeBidirectionalIterator<T> {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Map(node) => Self::Map(*node),
+        }
+    }
+}
+
+impl<T> PartialEq for UnsafeBidirectionalIterator<T> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Map(a), Self::Map(b)) => a == b,
+        }
+    }
+}
+
+impl<T> UnsafeCppIterator<T> for UnsafeBidirectionalIterator<T> {
+    fn iter_deref(&self) -> *mut T {
+        match self {
+            Self::Map(node) => UnsafeMapNode::value(*node),
+        }
+    }
+    fn iter_inc(&mut self) -> Self {
+        match self {
+            Self::Map(node) => *node = UnsafeMapNode::next(*node),
+        }
+        self.clone()
+    }
+    fn iter_post_inc(&mut self) -> Self {
+        let old = self.clone();
+        self.iter_inc();
+        old
+    }
+}
+
+impl<T> UnsafeCppInputIterator<T> for UnsafeBidirectionalIterator<T> {}
+
+impl<T> UnsafeCppBidirectionalIterator<T> for UnsafeBidirectionalIterator<T> {
+    fn iter_dec(&mut self) -> Self {
+        match self {
+            Self::Map(node) => *node = UnsafeMapNode::prev(*node),
+        }
+        self.clone()
+    }
+    fn iter_post_dec(&mut self) -> Self {
+        let old = self.clone();
+        self.iter_dec();
+        old
+    }
+}
+
+macro_rules! random_access_iterator {
+    ($name:ident, $ptr:ty, $iter:ident, $input:ident, $bidi:ident, $random:ident, $null:expr) => {
+        pub enum $name<T> {
+            Vec($ptr),
+        }
+
+        impl<T> $name<T> {
+            pub fn vec_ptr(&self) -> $ptr {
+                match self {
+                    Self::Vec(p) => p.clone(),
+                }
+            }
+        }
+
+        impl<T> Default for $name<T> {
+            fn default() -> Self {
+                Self::Vec($null)
+            }
+        }
+
+        impl<T> Clone for $name<T> {
+            fn clone(&self) -> Self {
+                Self::Vec(self.vec_ptr())
+            }
+        }
+
+        impl<T> PartialEq for $name<T> {
+            fn eq(&self, other: &Self) -> bool {
+                match (self, other) {
+                    (Self::Vec(a), Self::Vec(b)) => a == b,
+                }
+            }
+        }
+
+        impl<T> PartialOrd for $name<T> {
+            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+                match (self, other) {
+                    (Self::Vec(a), Self::Vec(b)) => a.partial_cmp(b),
+                }
+            }
+        }
+
+        impl<T> $iter<T> for $name<T> {
+            fn iter_deref(&self) -> $ptr {
+                match self {
+                    Self::Vec(p) => $iter::<T>::iter_deref(p),
+                }
+            }
+            fn iter_inc(&mut self) -> Self {
+                match self {
+                    Self::Vec(p) => Self::Vec($iter::<T>::iter_inc(p)),
+                }
+            }
+            fn iter_post_inc(&mut self) -> Self {
+                match self {
+                    Self::Vec(p) => Self::Vec($iter::<T>::iter_post_inc(p)),
+                }
+            }
+        }
+
+        impl<T> $input<T> for $name<T> {}
+
+        impl<T> $bidi<T> for $name<T> {
+            fn iter_dec(&mut self) -> Self {
+                match self {
+                    Self::Vec(p) => Self::Vec($bidi::<T>::iter_dec(p)),
+                }
+            }
+            fn iter_post_dec(&mut self) -> Self {
+                match self {
+                    Self::Vec(p) => Self::Vec($bidi::<T>::iter_post_dec(p)),
+                }
+            }
+        }
+
+        impl<T> $random<T> for $name<T> {
+            fn iter_add(&self, n: isize) -> Self {
+                match self {
+                    Self::Vec(p) => Self::Vec($random::<T>::iter_add(p, n)),
+                }
+            }
+            fn iter_add_assign(&mut self, n: isize) -> Self {
+                match self {
+                    Self::Vec(p) => Self::Vec($random::<T>::iter_add_assign(p, n)),
+                }
+            }
+            fn iter_distance(&self, from: &Self) -> isize {
+                match (self, from) {
+                    (Self::Vec(a), Self::Vec(b)) => $random::<T>::iter_distance(a, b),
+                }
+            }
+            fn iter_at(&self, n: isize) -> $ptr {
+                match self {
+                    Self::Vec(p) => $random::<T>::iter_at(p, n),
+                }
+            }
+        }
+    };
+}
+
+random_access_iterator!(
+    RandomAccessIterator,
+    Ptr<T>,
+    CppIterator,
+    CppInputIterator,
+    CppBidirectionalIterator,
+    CppRandomAccessIterator,
+    Ptr::null()
+);
+
+random_access_iterator!(
+    UnsafeRandomAccessIterator,
+    *mut T,
+    UnsafeCppIterator,
+    UnsafeCppInputIterator,
+    UnsafeCppBidirectionalIterator,
+    UnsafeCppRandomAccessIterator,
+    std::ptr::null_mut()
+);
diff --git a/rules/iterator_category/src.cpp b/rules/iterator_category/src.cpp
new file mode 100644
index 000000000..35c3670e7
--- /dev/null
+++ b/rules/iterator_category/src.cpp
@@ -0,0 +1,389 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include "../common/init.h"
+
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::input_iterator_tag,
+            typename std::iterator_traits<It>::iterator_category>::value &&
+        !std::is_base_of<
+            std::forward_iterator_tag,
+            typename std::iterator_traits<It>::iterator_category>::value &&
+        !std::is_pointer<It>::value>::type>
+using t1 = It;
+
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::output_iterator_tag,
+            typename std::iterator_traits<It>::iterator_category>::value &&
+        !std::is_pointer<It>::value>::type>
+using t2 = It;
+
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::forward_iterator_tag,
+            typename std::iterator_traits<It>::iterator_category>::value &&
+        !std::is_base_of<
+            std::bidirectional_iterator_tag,
+            typename std::iterator_traits<It>::iterator_category>::value &&
+        !std::is_pointer<It>::value>::type>
+using t3 = It;
+
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::bidirectional_iterator_tag,
+            typename std::iterator_traits<It>::iterator_category>::value &&
+        !std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<It>::iterator_category>::value &&
+        !std::is_pointer<It>::value>::type>
+using t4 = It;
+
+template <
+    typename It, typename T1 = typename std::iterator_traits<It>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<It>::iterator_category>::value &&
+        !std::is_pointer<It>::value>::type>
+using t5 = It;
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        !std::is_pointer<T1>::value>::type>
+T1 f1(const T1 &a0) {
+  return T1(a0);
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        !std::is_pointer<T1>::value && !std::is_reference<T1>::value>::type>
+typename std::remove_reference<T1>::type f2(T1 &&a0) {
+  return T1(std::move(a0));
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        !std::is_pointer<T1>::value>::type>
+T1 &f3(T1 &a0, const T1 &a1) {
+  return a0 = a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        !std::is_pointer<T1>::value>::type>
+T1 &f4(T1 &a0, T1 &&a1) {
+  return a0 = std::move(a1);
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        !std::is_pointer<T1>::value>::type>
+decltype(*std::declval<const T1 &>()) f5(const T1 &a0) {
+  return *a0;
+}
+
+template <
+    typename T3, typename T1 = typename std::remove_reference<T3>::type,
+    typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        !std::is_pointer<T1>::value &&
+        std::is_lvalue_reference<T3>::value>::type>
+T1 &f6(T3 &&a0) {
+  return ++a0;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        !std::is_pointer<T1>::value>::type>
+decltype(std::declval<T1 &>()++) f7(T1 &a0, int) {
+  return a0++;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::input_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+typename std::iterator_traits<T1>::pointer f8(const T1 &a0) {
+  return a0.operator->();
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::input_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+bool f9(const T1 &a0, const T1 &a1) {
+  return a0 == a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::input_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+bool f10(const T1 &a0, const T1 &a1) {
+  return a0 != a1;
+}
+
+template <typename T3, typename T1 = typename std::remove_reference<T3>::type,
+          typename T2 = typename std::iterator_traits<T1>::value_type,
+          typename = typename std::enable_if<
+              std::is_base_of<std::bidirectional_iterator_tag,
+                              typename std::iterator_traits<
+                                  T1>::iterator_category>::value &&
+              !std::is_pointer<T1>::value &&
+              std::is_lvalue_reference<T3>::value>::type>
+T1 &f11(T3 &&a0) {
+  return --a0;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::bidirectional_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+decltype(std::declval<T1 &>()--) f12(T1 &a0, int) {
+  return a0--;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+T1 &f13(T1 &a0, typename std::iterator_traits<T1>::difference_type a1) {
+  return a0 += a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+T1 &f14(T1 &a0, typename std::iterator_traits<T1>::difference_type a1) {
+  return a0 -= a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+T1 f15(const T1 &a0, typename std::iterator_traits<T1>::difference_type a1) {
+  return a0 + a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+T1 f16(typename std::iterator_traits<T1>::difference_type a0, const T1 &a1) {
+  return a0 + a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+T1 f17(const T1 &a0, typename std::iterator_traits<T1>::difference_type a1) {
+  return a0 - a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+typename std::iterator_traits<T1>::difference_type f18(const T1 &a0,
+                                                       const T1 &a1) {
+  return a0 - a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+typename std::iterator_traits<T1>::reference
+f19(const T1 &a0, typename std::iterator_traits<T1>::difference_type a1) {
+  return a0[a1];
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+bool f20(const T1 &a0, const T1 &a1) {
+  return a0 < a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+bool f21(const T1 &a0, const T1 &a1) {
+  return a0 > a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+bool f22(const T1 &a0, const T1 &a1) {
+  return a0 <= a1;
+}
+
+template <
+    typename T1, typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value>::type>
+bool f23(const T1 &a0, const T1 &a1) {
+  return a0 >= a1;
+}
+
+template <
+    typename T1, typename T2,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T2>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T2>::iterator_category>::value) &&
+        !std::is_same<T1, T2>::value && std::is_convertible<T2, T1>::value &&
+        !std::is_pointer<T1>::value && !std::is_pointer<T2>::value>::type>
+T1 f24(const T2 &a0) {
+  return T1(a0);
+}
+
+template <
+    typename T3, typename T1 = typename std::remove_reference<T3>::type,
+    typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        (std::is_base_of<
+             std::input_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value ||
+         std::is_base_of<
+             std::output_iterator_tag,
+             typename std::iterator_traits<T1>::iterator_category>::value) &&
+        !std::is_pointer<T1>::value && !std::is_reference<T3>::value>::type>
+T1 &f25(T3 &&a0) {
+  return ++a0;
+}
+
+template <
+    typename T3, typename T1 = typename std::remove_reference<T3>::type,
+    typename T2 = typename std::iterator_traits<T1>::value_type,
+    typename = typename std::enable_if<
+        std::is_base_of<
+            std::bidirectional_iterator_tag,
+            typename std::iterator_traits<T1>::iterator_category>::value &&
+        !std::is_pointer<T1>::value && !std::is_reference<T3>::value>::type>
+T1 &f26(T3 &&a0) {
+  return --a0;
+}
diff --git a/rules/iterator_category/tgt_refcount.rs b/rules/iterator_category/tgt_refcount.rs
new file mode 100644
index 000000000..30d650046
--- /dev/null
+++ b/rules/iterator_category/tgt_refcount.rs
@@ -0,0 +1,130 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs::*;
+
+fn t1<T1>() -> InputIterator<T1> {
+    InputIterator::uninitialized()
+}
+
+fn t2<T1>() -> OutputIterator<T1> {
+    OutputIterator::uninitialized()
+}
+
+fn t3<T1>() -> ForwardIterator<T1> {
+    ForwardIterator::uninitialized()
+}
+
+fn t4<T1>() -> BidirectionalIterator<T1> {
+    BidirectionalIterator::default()
+}
+
+fn t5<T1>() -> RandomAccessIterator<T1> {
+    RandomAccessIterator::default()
+}
+
+fn f1<T1: CppIterator<T2>, T2>(a0: T1) -> T1 {
+    (a0).clone()
+}
+
+fn f2<T1: CppIterator<T2>, T2>(a0: T1) -> T1 {
+    a0
+}
+
+fn f3<T1: CppIterator<T2>, T2>(a0: &mut T1, a1: T1) {
+    *a0 = a1.clone()
+}
+
+fn f4<T1: CppIterator<T2>, T2>(a0: &mut T1, a1: T1) {
+    *a0 = a1
+}
+
+fn f5<T1: CppIterator<T2>, T2>(a0: T1) -> Ptr<T2> {
+    a0.iter_deref()
+}
+
+fn f6<T1: CppIterator<T2>, T2>(a0: &mut T1) -> T1 {
+    a0.iter_inc()
+}
+
+fn f7<T1: CppIterator<T2>, T2>(a0: &mut T1) -> T1 {
+    a0.iter_post_inc()
+}
+
+fn f8<T1: CppInputIterator<T2>, T2>(a0: T1) -> Ptr<T2> {
+    a0.iter_deref()
+}
+
+fn f9<T1: CppInputIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 == a1
+}
+
+fn f10<T1: CppInputIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 != a1
+}
+
+fn f11<T1: CppBidirectionalIterator<T2>, T2>(a0: &mut T1) -> T1 {
+    a0.iter_dec()
+}
+
+fn f12<T1: CppBidirectionalIterator<T2>, T2>(a0: &mut T1) -> T1 {
+    a0.iter_post_dec()
+}
+
+fn f13<T1: CppRandomAccessIterator<T2>, T2>(a0: &mut T1, a1: isize) -> T1 {
+    a0.iter_add_assign(a1)
+}
+
+fn f14<T1: CppRandomAccessIterator<T2>, T2>(a0: &mut T1, a1: isize) -> T1 {
+    a0.iter_add_assign(-a1)
+}
+
+fn f15<T1: CppRandomAccessIterator<T2>, T2>(a0: T1, a1: isize) -> T1 {
+    a0.iter_add(a1)
+}
+
+fn f16<T1: CppRandomAccessIterator<T2>, T2>(a0: isize, a1: T1) -> T1 {
+    a1.iter_add(a0)
+}
+
+fn f17<T1: CppRandomAccessIterator<T2>, T2>(a0: T1, a1: isize) -> T1 {
+    a0.iter_add(-a1)
+}
+
+fn f18<T1: CppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> isize {
+    a0.iter_distance(&a1)
+}
+
+fn f19<T1: CppRandomAccessIterator<T2>, T2>(a0: T1, a1: isize) -> Ptr<T2> {
+    a0.iter_at(a1)
+}
+
+fn f20<T1: CppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 < a1
+}
+
+fn f21<T1: CppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 > a1
+}
+
+fn f22<T1: CppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 <= a1
+}
+
+fn f23<T1: CppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 >= a1
+}
+
+fn f24<T1: From<T2>, T2>(a0: T2) -> T1 {
+    <T1>::from(a0)
+}
+
+fn f25<T1: CppIterator<T2>, T2>(a0: T1) -> T1 {
+    let mut __it = a0;
+    __it.iter_inc()
+}
+
+fn f26<T1: CppBidirectionalIterator<T2>, T2>(a0: T1) -> T1 {
+    let mut __it = a0;
+    __it.iter_dec()
+}
diff --git a/rules/iterator_category/tgt_unsafe.rs b/rules/iterator_category/tgt_unsafe.rs
new file mode 100644
index 000000000..49694d5eb
--- /dev/null
+++ b/rules/iterator_category/tgt_unsafe.rs
@@ -0,0 +1,130 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use libcc2rs::*;
+
+fn t1<T1>() -> UnsafeInputIterator<T1> {
+    UnsafeInputIterator::uninitialized()
+}
+
+fn t2<T1>() -> UnsafeOutputIterator<T1> {
+    UnsafeOutputIterator::uninitialized()
+}
+
+fn t3<T1>() -> UnsafeForwardIterator<T1> {
+    UnsafeForwardIterator::uninitialized()
+}
+
+fn t4<T1>() -> UnsafeBidirectionalIterator<T1> {
+    UnsafeBidirectionalIterator::default()
+}
+
+fn t5<T1>() -> UnsafeRandomAccessIterator<T1> {
+    UnsafeRandomAccessIterator::default()
+}
+
+unsafe fn f1<T1: UnsafeCppIterator<T2>, T2>(a0: T1) -> T1 {
+    (a0).clone()
+}
+
+unsafe fn f2<T1: UnsafeCppIterator<T2>, T2>(a0: T1) -> T1 {
+    a0
+}
+
+unsafe fn f3<T1: UnsafeCppIterator<T2>, T2>(a0: &mut T1, a1: T1) {
+    *a0 = a1.clone()
+}
+
+unsafe fn f4<T1: UnsafeCppIterator<T2>, T2>(a0: &mut T1, a1: T1) {
+    *a0 = a1
+}
+
+unsafe fn f5<T1: UnsafeCppIterator<T2>, T2>(a0: T1) -> *mut T2 {
+    a0.iter_deref()
+}
+
+unsafe fn f6<T1: UnsafeCppIterator<T2>, T2>(a0: &mut T1) -> T1 {
+    a0.iter_inc()
+}
+
+unsafe fn f7<T1: UnsafeCppIterator<T2>, T2>(a0: &mut T1) -> T1 {
+    a0.iter_post_inc()
+}
+
+unsafe fn f8<T1: UnsafeCppInputIterator<T2>, T2>(a0: T1) -> *mut T2 {
+    a0.iter_deref()
+}
+
+unsafe fn f9<T1: UnsafeCppInputIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 == a1
+}
+
+unsafe fn f10<T1: UnsafeCppInputIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 != a1
+}
+
+unsafe fn f11<T1: UnsafeCppBidirectionalIterator<T2>, T2>(a0: &mut T1) -> T1 {
+    a0.iter_dec()
+}
+
+unsafe fn f12<T1: UnsafeCppBidirectionalIterator<T2>, T2>(a0: &mut T1) -> T1 {
+    a0.iter_post_dec()
+}
+
+unsafe fn f13<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: &mut T1, a1: isize) -> T1 {
+    a0.iter_add_assign(a1)
+}
+
+unsafe fn f14<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: &mut T1, a1: isize) -> T1 {
+    a0.iter_add_assign(-a1)
+}
+
+unsafe fn f15<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: T1, a1: isize) -> T1 {
+    a0.iter_add(a1)
+}
+
+unsafe fn f16<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: isize, a1: T1) -> T1 {
+    a1.iter_add(a0)
+}
+
+unsafe fn f17<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: T1, a1: isize) -> T1 {
+    a0.iter_add(-a1)
+}
+
+unsafe fn f18<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> isize {
+    a0.iter_distance(&a1)
+}
+
+unsafe fn f19<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: T1, a1: isize) -> *mut T2 {
+    a0.iter_at(a1)
+}
+
+unsafe fn f20<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 < a1
+}
+
+unsafe fn f21<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 > a1
+}
+
+unsafe fn f22<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 <= a1
+}
+
+unsafe fn f23<T1: UnsafeCppRandomAccessIterator<T2>, T2>(a0: T1, a1: T1) -> bool {
+    a0 >= a1
+}
+
+unsafe fn f24<T1: From<T2>, T2>(a0: T2) -> T1 {
+    <T1>::from(a0)
+}
+
+unsafe fn f25<T1: UnsafeCppIterator<T2>, T2>(a0: T1) -> T1 {
+    let mut __it = a0;
+    __it.iter_inc()
+}
+
+unsafe fn f26<T1: UnsafeCppBidirectionalIterator<T2>, T2>(a0: T1) -> T1 {
+    let mut __it = a0;
+    __it.iter_dec()
+}
diff --git a/rules/map/shim.rs b/rules/map/shim.rs
new file mode 100644
index 000000000..d5f68c324
--- /dev/null
+++ b/rules/map/shim.rs
@@ -0,0 +1,433 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::ops::Bound;
+use std::rc::{Rc, Weak};
+
+use crate::{
+    AsPointer, BidirectionalIterator, ByteRepr, CppIterator, Ptr, UnsafeBidirectionalIterator,
+    UnsafeCppIterator, Value,
+};
+
+pub trait MapEntry<K> {
+    fn key(&self) -> K;
+}
+
+impl<K: Clone, V> MapEntry<K> for (Value<K>, Value<V>) {
+    fn key(&self) -> K {
+        self.0.borrow().clone()
+    }
+}
+
+impl<K: Clone, V> MapEntry<K> for (K, V) {
+    fn key(&self) -> K {
+        self.0.clone()
+    }
+}
+
+pub struct MapNode<T> {
+    value: Option<Value<T>>,
+    prev: Weak<RefCell<MapNode<T>>>,
+    next: Weak<RefCell<MapNode<T>>>,
+}
+
+impl<T> MapNode<T> {
+    pub(crate) fn header() -> Value<Self> {
+        let header = Rc::new(RefCell::new(MapNode {
+            value: None,
+            prev: Weak::new(),
+            next: Weak::new(),
+        }));
+        {
+            let mut node = header.borrow_mut();
+            node.prev = Rc::downgrade(&header);
+            node.next = Rc::downgrade(&header);
+        }
+        header
+    }
+
+    pub(crate) fn next(node: &Value<Self>) -> Value<Self> {
+        node.borrow()
+            .next
+            .upgrade()
+            .expect("ub: increment of an invalid map iterator")
+    }
+
+    pub(crate) fn prev(node: &Value<Self>) -> Value<Self> {
+        node.borrow()
+            .prev
+            .upgrade()
+            .expect("ub: decrement of an invalid map iterator")
+    }
+
+    pub(crate) fn value(node: &Value<Self>) -> Ptr<T> {
+        node.borrow()
+            .value
+            .as_ref()
+            .expect("ub: dereference of end iterator")
+            .as_pointer()
+    }
+}
+
+pub struct Map<K, T> {
+    nodes: BTreeMap<K, Value<MapNode<T>>>,
+    header: Value<MapNode<T>>,
+}
+
+impl<K, T> Default for Map<K, T> {
+    fn default() -> Self {
+        Self {
+            nodes: BTreeMap::new(),
+            header: MapNode::header(),
+        }
+    }
+}
+
+impl<K: 'static, T: 'static> ByteRepr for Map<K, T> {}
+
+impl<K: Ord + Clone, T> Clone for Map<K, T> {
+    fn clone(&self) -> Self {
+        let mut map = Self::default();
+        for (key, value) in self.entries() {
+            map.link(key.clone(), value);
+        }
+        map
+    }
+}
+
+impl<K, T> Map<K, T> {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn len(&self) -> usize {
+        self.nodes.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.nodes.is_empty()
+    }
+
+    pub fn begin(&self) -> BidirectionalIterator<T> {
+        BidirectionalIterator::Map(MapNode::next(&self.header))
+    }
+
+    pub fn end(&self) -> BidirectionalIterator<T> {
+        BidirectionalIterator::Map(self.header.clone())
+    }
+
+    pub fn entries(&self) -> impl Iterator<Item = (&K, Value<T>)> + '_ {
+        self.nodes.iter().map(|(key, node)| {
+            let value = node.borrow().value.clone();
+            (key, value.expect("map node without a value"))
+        })
+    }
+}
+
+impl<K: Ord, T> Map<K, T> {
+    fn link(&mut self, key: K, value: Value<T>) -> Value<MapNode<T>> {
+        let prev = self
+            .nodes
+            .range((Bound::Unbounded, Bound::Excluded(&key)))
+            .next_back()
+            .map(|(_, node)| node.clone())
+            .unwrap_or_else(|| self.header.clone());
+        let next = MapNode::next(&prev);
+        let node = Rc::new(RefCell::new(MapNode {
+            value: Some(value),
+            prev: Rc::downgrade(&prev),
+            next: Rc::downgrade(&next),
+        }));
+        prev.borrow_mut().next = Rc::downgrade(&node);
+        next.borrow_mut().prev = Rc::downgrade(&node);
+        self.nodes.insert(key, node.clone());
+        node
+    }
+
+    pub fn get(&self, key: &K) -> Option<Value<T>> {
+        self.nodes.get(key).map(|node| {
+            node.borrow()
+                .value
+                .clone()
+                .expect("map node without a value")
+        })
+    }
+
+    pub fn get_or_insert_with(&mut self, key: K, value: impl FnOnce() -> T) -> Value<T> {
+        if let Some(existing) = self.get(&key) {
+            return existing;
+        }
+        let value = Rc::new(RefCell::new(value()));
+        self.link(key, value.clone());
+        value
+    }
+
+    pub fn insert(&mut self, key: K, value: Value<T>) {
+        if !self.nodes.contains_key(&key) {
+            self.link(key, value);
+        }
+    }
+
+    pub fn find(&self, key: &K) -> BidirectionalIterator<T> {
+        match self.nodes.get(key) {
+            Some(node) => BidirectionalIterator::Map(node.clone()),
+            None => self.end(),
+        }
+    }
+
+    fn unlink(node: &Value<MapNode<T>>) -> Value<MapNode<T>> {
+        let prev = MapNode::prev(node);
+        let next = MapNode::next(node);
+        prev.borrow_mut().next = Rc::downgrade(&next);
+        next.borrow_mut().prev = Rc::downgrade(&prev);
+        next
+    }
+
+    pub fn erase(&mut self, it: &BidirectionalIterator<T>) -> BidirectionalIterator<T>
+    where
+        T: MapEntry<K>,
+    {
+        let BidirectionalIterator::Map(node) = it;
+        let key = node
+            .borrow()
+            .value
+            .as_ref()
+            .expect("ub: erase of end iterator")
+            .borrow()
+            .key();
+        let next = Self::unlink(node);
+        self.nodes.remove(&key);
+        BidirectionalIterator::Map(next)
+    }
+
+    pub fn erase_key(&mut self, key: &K) -> usize {
+        match self.nodes.remove(key) {
+            Some(node) => {
+                Self::unlink(&node);
+                1
+            }
+            None => 0,
+        }
+    }
+}
+
+impl<K: 'static, T: 'static> Map<K, T> {
+    pub fn range(map: Ptr<Self>) -> MapRange<T> {
+        map.with(|map| MapRange {
+            cur: map.begin(),
+            end: map.end(),
+        })
+    }
+}
+
+pub struct MapRange<T> {
+    cur: BidirectionalIterator<T>,
+    end: BidirectionalIterator<T>,
+}
+
+impl<T> Iterator for MapRange<T> {
+    type Item = BidirectionalIterator<T>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.cur == self.end {
+            return None;
+        }
+        Some(self.cur.iter_post_inc())
+    }
+}
+
+pub struct UnsafeMapNode<T> {
+    value: Option<T>,
+    prev: *mut UnsafeMapNode<T>,
+    next: *mut UnsafeMapNode<T>,
+}
+
+impl<T> UnsafeMapNode<T> {
+    fn header() -> Box<Self> {
+        let mut header = Box::new(UnsafeMapNode {
+            value: None,
+            prev: std::ptr::null_mut(),
+            next: std::ptr::null_mut(),
+        });
+        let ptr: *mut Self = &mut *header;
+        header.prev = ptr;
+        header.next = ptr;
+        header
+    }
+
+    pub(crate) fn next(node: *mut Self) -> *mut Self {
+        unsafe { (*node).next }
+    }
+
+    pub(crate) fn prev(node: *mut Self) -> *mut Self {
+        unsafe { (*node).prev }
+    }
+
+    pub(crate) fn value(node: *mut Self) -> *mut T {
+        unsafe {
+            (*node)
+                .value
+                .as_mut()
+                .expect("ub: dereference of end iterator") as *mut T
+        }
+    }
+}
+
+pub struct UnsafeMap<K, T> {
+    nodes: BTreeMap<K, Box<UnsafeMapNode<T>>>,
+    header: Box<UnsafeMapNode<T>>,
+}
+
+impl<K, T> Default for UnsafeMap<K, T> {
+    fn default() -> Self {
+        Self {
+            nodes: BTreeMap::new(),
+            header: UnsafeMapNode::header(),
+        }
+    }
+}
+
+impl<K: Ord + Clone, T: Clone> Clone for UnsafeMap<K, T> {
+    fn clone(&self) -> Self {
+        let mut map = Self::default();
+        for (key, node) in &self.nodes {
+            map.link(
+                key.clone(),
+                node.value.clone().expect("map node without a value"),
+            );
+        }
+        map
+    }
+}
+
+impl<K, T> UnsafeMap<K, T> {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn len(&self) -> usize {
+        self.nodes.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.nodes.is_empty()
+    }
+
+    fn header_ptr(&self) -> *mut UnsafeMapNode<T> {
+        &*self.header as *const UnsafeMapNode<T> as *mut UnsafeMapNode<T>
+    }
+
+    pub fn begin(&self) -> UnsafeBidirectionalIterator<T> {
+        UnsafeBidirectionalIterator::Map(UnsafeMapNode::next(self.header_ptr()))
+    }
+
+    pub fn end(&self) -> UnsafeBidirectionalIterator<T> {
+        UnsafeBidirectionalIterator::Map(self.header_ptr())
+    }
+
+    /// # Safety
+    /// `map` must point to a live map.
+    pub unsafe fn range(map: *const Self) -> UnsafeMapRange<T> {
+        unsafe {
+            UnsafeMapRange {
+                cur: (*map).begin(),
+                end: (*map).end(),
+            }
+        }
+    }
+}
+
+impl<K: Ord, T> UnsafeMap<K, T> {
+    fn link(&mut self, key: K, value: T) -> *mut UnsafeMapNode<T> {
+        let prev = self
+            .nodes
+            .range((Bound::Unbounded, Bound::Excluded(&key)))
+            .next_back()
+            .map(|(_, node)| &**node as *const UnsafeMapNode<T> as *mut UnsafeMapNode<T>)
+            .unwrap_or_else(|| self.header_ptr());
+        let next = UnsafeMapNode::next(prev);
+        let mut node = Box::new(UnsafeMapNode {
+            value: Some(value),
+            prev,
+            next,
+        });
+        let ptr: *mut UnsafeMapNode<T> = &mut *node;
+        unsafe {
+            (*prev).next = ptr;
+            (*next).prev = ptr;
+        }
+        self.nodes.insert(key, node);
+        ptr
+    }
+
+    pub fn get(&self, key: &K) -> Option<*mut T> {
+        self.nodes.get(key).map(|node| {
+            UnsafeMapNode::value(&**node as *const UnsafeMapNode<T> as *mut UnsafeMapNode<T>)
+        })
+    }
+
+    pub fn get_or_insert_with(&mut self, key: K, value: impl FnOnce() -> T) -> *mut T {
+        if let Some(existing) = self.get(&key) {
+            return existing;
+        }
+        UnsafeMapNode::value(self.link(key, value()))
+    }
+
+    pub fn find(&self, key: &K) -> UnsafeBidirectionalIterator<T> {
+        match self.nodes.get(key) {
+            Some(node) => UnsafeBidirectionalIterator::Map(
+                &**node as *const UnsafeMapNode<T> as *mut UnsafeMapNode<T>,
+            ),
+            None => self.end(),
+        }
+    }
+
+    fn unlink(node: *mut UnsafeMapNode<T>) -> *mut UnsafeMapNode<T> {
+        let prev = UnsafeMapNode::prev(node);
+        let next = UnsafeMapNode::next(node);
+        unsafe {
+            (*prev).next = next;
+            (*next).prev = prev;
+        }
+        next
+    }
+
+    pub fn erase(&mut self, it: &UnsafeBidirectionalIterator<T>) -> UnsafeBidirectionalIterator<T>
+    where
+        T: MapEntry<K>,
+    {
+        let UnsafeBidirectionalIterator::Map(node) = *it;
+        let key = unsafe { (*UnsafeMapNode::value(node)).key() };
+        let next = Self::unlink(node);
+        self.nodes.remove(&key);
+        UnsafeBidirectionalIterator::Map(next)
+    }
+
+    pub fn erase_key(&mut self, key: &K) -> usize {
+        match self.nodes.remove(key) {
+            Some(mut node) => {
+                Self::unlink(&mut *node);
+                1
+            }
+            None => 0,
+        }
+    }
+}
+
+pub struct UnsafeMapRange<T> {
+    cur: UnsafeBidirectionalIterator<T>,
+    end: UnsafeBidirectionalIterator<T>,
+}
+
+impl<T> Iterator for UnsafeMapRange<T> {
+    type Item = UnsafeBidirectionalIterator<T>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.cur == self.end {
+            return None;
+        }
+        Some(self.cur.iter_post_inc())
+    }
+}
diff --git a/rules/map/src.cpp b/rules/map/src.cpp
index 7d8618237..8bf47b3b1 100644
--- a/rules/map/src.cpp
+++ b/rules/map/src.cpp
@@ -6,18 +6,8 @@
 #include <type_traits>
 #include <utility>
 
-#include "../common/traits.h"
-
 template <typename T1, typename T2> using t1 = std::map<T1, T2>;
 
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::const_iterator>>
-using t2 = It;
-
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::iterator>>
-using t3 = It;
-
 template <typename T1, typename T2>
 using t4 = typename std::map<T1, T2>::size_type;
 
@@ -62,23 +52,11 @@ typename std::map<T1, T2>::iterator f10(std::map<T1, T2> &o, const T1 &key) {
   return o.find(key);
 }
 
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::iterator>>
-bool f11(It a, It b) {
-  return a != b;
-}
-
 template <typename T1, typename T2>
 typename std::map<T1, T2>::iterator f12(std::map<T1, T2> &o) {
   return o.begin();
 }
 
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::const_iterator>>
-bool f13(It a, It b) {
-  return a == b;
-}
-
 template <typename T1, typename T2>
 typename std::map<T1, T2>::iterator f14(std::map<T1, T2> &o) {
   return o.end();
@@ -89,48 +67,12 @@ const T2 &f15(const std::map<T1, T2> &o, const T1 &key) {
   return o.at(key);
 }
 
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::iterator>>
-bool f16(It a, It b) {
-  return a == b;
-}
-
 template <typename T1, typename T2>
 typename std::map<T1, T2>::const_iterator f17(const std::map<T1, T2> &o,
                                               const T1 &key) {
   return o.find(key);
 }
 
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::iterator>>
-typename std::map<T1, T2>::const_iterator f19(const It &it) {
-  return typename std::map<T1, T2>::const_iterator(it);
-}
-
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::const_iterator>>
-const T1 &f20(It it) {
-  return it->first;
-}
-
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::const_iterator>>
-const T2 &f21(It it) {
-  return it->second;
-}
-
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::iterator>>
-const T1 &f22(It it) {
-  return it->first;
-}
-
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::iterator>>
-T2 &f23(It it) {
-  return it->second;
-}
-
 template <typename T1, typename T2> std::map<T1, T2> f24(std::map<T1, T2> &&o) {
   return std::map<T1, T2>(std::move(o));
 }
@@ -145,14 +87,14 @@ std::map<T1, T2> &f26(std::map<T1, T2> &dst, const std::map<T1, T2> &src) {
   return dst = src;
 }
 
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::iterator>>
-std::pair<const T1, T2> &f27(It it) {
-  return *it;
+template <typename T1, typename T2>
+typename std::map<T1, T2>::iterator
+f27(std::map<T1, T2> &o, typename std::map<T1, T2>::const_iterator it) {
+  return o.erase(it);
 }
 
-template <typename It, typename T1 = KeyOf<It>, typename T2 = MappedOf<It>,
-          typename = SameAs<It, typename std::map<T1, T2>::const_iterator>>
-const std::pair<const T1, T2> &f28(It it) {
-  return *it;
+template <typename T1, typename T2>
+std::size_t f28(std::map<T1, T2> &o,
+                const typename std::map<T1, T2>::key_type &key) {
+  return o.erase(key);
 }
diff --git a/rules/map/tgt_refcount.rs b/rules/map/tgt_refcount.rs
index 8e641ab8e..bf74b5956 100644
--- a/rules/map/tgt_refcount.rs
+++ b/rules/map/tgt_refcount.rs
@@ -3,225 +3,135 @@
 
 use libcc2rs::*;
 use std::cell::RefCell;
-use std::collections::BTreeMap;
 use std::rc::Rc;
 
-fn t1<T1, T2>() -> BTreeMap<T1, Value<(Value<T1>, Value<T2>)>> {
-    BTreeMap::new()
-}
-
-fn t2<T1: Clone + Ord + 'static, T2: 'static>() -> RefcountMapIter<T1, T2> {
-    RefcountMapIter::null()
-}
-
-fn t3<T1: Clone + Ord + 'static, T2: 'static>() -> RefcountMapIter<T1, T2> {
-    RefcountMapIter::null()
+fn t1<T1, T2>() -> Map<T1, (Value<T1>, Value<T2>)> {
+    Map::new()
 }
 
 fn f1<T1: Ord + Clone + ByteRepr + 'static, T2: Default + ByteRepr + 'static>(
-    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
+    a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>,
     a1: T1,
 ) -> Ptr<T2> {
-    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()
+    a0.with_mut(|__m: &mut Map<T1, (Value<T1>, Value<T2>)>| {
+        __m.get_or_insert_with(a1.clone(), || {
+            (
+                Rc::new(RefCell::new(a1)),
+                Rc::new(RefCell::new(<T2>::default())),
+            )
+        })
+        .borrow()
+        .1
+        .as_pointer()
     })
 }
 
-fn f2<T1, T2>(a0: BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>) -> usize {
+fn f2<T1, T2>(a0: Map<T1, (Value<T1>, Value<T2>)>) -> usize {
     a0.len()
 }
 
 fn f3<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
-    a1: RefcountMapIter<T1, T2>,
-) -> RefcountMapIter<T1, T2> {
-    RefcountMapIter::erase(a0, &a1)
+    a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>,
+    a1: BidirectionalIterator<(Value<T1>, Value<T2>)>,
+) -> BidirectionalIterator<(Value<T1>, Value<T2>)> {
+    a0.with_mut(|__m: &mut Map<T1, (Value<T1>, Value<T2>)>| __m.erase(&a1))
 }
 
-fn f5<T1, T2>() -> BTreeMap<T1, Value<(Value<T1>, Value<T2>)>> {
-    BTreeMap::new()
+fn f5<T1, T2>() -> Map<T1, (Value<T1>, Value<T2>)> {
+    Map::new()
 }
 
-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)| {
-            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 f6<T1: Ord + Clone, T2: Clone>(a0: Map<T1, (Value<T1>, Value<T2>)>) -> Map<T1, (Value<T1>, Value<T2>)> {
+    let mut __m = Map::new();
+    for (__k, __v) in a0.entries() {
+        let __v = __v.borrow();
+        __m.insert(
+            __k.clone(),
+            Rc::new(RefCell::new((
+                Rc::new(RefCell::new(__v.0.borrow().clone())),
+                Rc::new(RefCell::new(__v.1.borrow().clone())),
+            ))),
+        );
+    }
+    __m
 }
 
-fn f7<T1: Ord, T2: Default>(
-    a0: &mut BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>,
-    a1: T1,
-) -> Ptr<T2> {
+fn f7<T1: Ord, T2>(a0: &mut Map<T1, (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<(Value<T1>, Value<T2>)>>>,
+    a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>,
     a1: T1,
 ) -> Ptr<T2> {
-    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()
+    a0.with_mut(|__m: &mut Map<T1, (Value<T1>, Value<T2>)>| {
+        __m.get_or_insert_with(a1.clone(), || {
+            (
+                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<(Value<T1>, Value<T2>)>>>,
-) -> RefcountMapIter<T1, T2> {
-    RefcountMapIter::end(a0)
+fn f9<T1: 'static, T2: 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>) -> BidirectionalIterator<(Value<T1>, Value<T2>)> {
+    a0.with(|__m: &Map<T1, (Value<T1>, Value<T2>)>| __m.end())
 }
 
-fn f10<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
-    a1: T1,
-) -> RefcountMapIter<T1, T2> {
-    RefcountMapIter::find_key(a0, &a1)
+fn f10<T1: Ord + 'static, T2: 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>, a1: T1) -> BidirectionalIterator<(Value<T1>, Value<T2>)> {
+    a0.with(|__m: &Map<T1, (Value<T1>, Value<T2>)>| __m.find(&a1))
 }
 
-fn f11<T1: PartialEq, T2: PartialEq>(
-    a0: RefcountMapIter<T1, T2>,
-    a1: RefcountMapIter<T1, T2>,
-) -> bool {
-    a0 != a1
+fn f12<T1: 'static, T2: 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>) -> BidirectionalIterator<(Value<T1>, Value<T2>)> {
+    a0.with(|__m: &Map<T1, (Value<T1>, Value<T2>)>| __m.begin())
 }
 
-fn f12<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
-) -> RefcountMapIter<T1, T2> {
-    RefcountMapIter::begin(a0)
+fn f14<T1: 'static, T2: 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>) -> BidirectionalIterator<(Value<T1>, Value<T2>)> {
+    a0.with(|__m: &Map<T1, (Value<T1>, Value<T2>)>| __m.end())
 }
 
-fn f13<T1: PartialEq, T2: PartialEq>(
-    a0: RefcountMapIter<T1, T2>,
-    a1: RefcountMapIter<T1, T2>,
-) -> bool {
-    a0 == a1
-}
-
-fn f14<T1: Ord + Clone + 'static, T2: 'static>(
-    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<(Value<T1>, Value<T2>)>>,
-    a1: T1,
-) -> Ptr<T2> {
+fn f15<T1: Ord, T2>(a0: &mut Map<T1, (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>(
-    a0: RefcountMapIter<T1, T2>,
-    a1: RefcountMapIter<T1, T2>,
-) -> bool {
-    a0 == a1
-}
-
-fn f17<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
-    a1: T1,
-) -> RefcountMapIter<T1, T2> {
-    RefcountMapIter::find_key(a0, &a1)
-}
-
-fn f19<T1: Clone, T2>(a0: RefcountMapIter<T1, T2>) -> RefcountMapIter<T1, T2> {
-    a0
-}
-
-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 + ByteRepr + 'static, T2: ByteRepr + 'static>(
-    a0: RefcountMapIter<T1, T2>,
-) -> Value<T2> {
-    a0.deref().with(|__p| __p.1.clone())
-}
-
-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 + ByteRepr + 'static, T2: ByteRepr + 'static>(
-    a0: RefcountMapIter<T1, T2>,
-) -> Value<T2> {
-    a0.deref().with(|__p| __p.1.clone())
+fn f17<T1: Ord + 'static, T2: 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>, a1: T1) -> BidirectionalIterator<(Value<T1>, Value<T2>)> {
+    a0.with(|__m: &Map<T1, (Value<T1>, Value<T2>)>| __m.find(&a1))
 }
 
-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 f24<T1: 'static, T2: 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>) -> Map<T1, (Value<T1>, Value<T2>)> {
+    a0.with_mut(|__m: &mut Map<T1, (Value<T1>, Value<T2>)>| std::mem::take(__m))
 }
 
-fn f25<T1: 'static, T2: 'static>(
-    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<(Value<T1>, Value<T2>)>>| std::mem::take(__v));
+fn f25<T1: 'static, T2: 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>, a1: Ptr<Map<T1, (Value<T1>, Value<T2>)>>) {
+    let __src = a1.with_mut(|__m: &mut Map<T1, (Value<T1>, Value<T2>)>| std::mem::take(__m));
     a0.write(__src)
 }
 
-fn f26<T1: Ord + Clone + 'static, T2: Clone + 'static>(
-    a0: Ptr<BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>>,
-    a1: BTreeMap<T1, Value<(Value<T1>, Value<T2>)>>,
-) {
-    a0.write(
-        a1.iter()
-            .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 f26<T1: Ord + Clone + 'static, T2: Clone + 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>, a1: Map<T1, (Value<T1>, Value<T2>)>) {
+    let mut __m = Map::new();
+    for (__k, __v) in a1.entries() {
+        let __v = __v.borrow();
+        __m.insert(
+            __k.clone(),
+            Rc::new(RefCell::new((
+                Rc::new(RefCell::new(__v.0.borrow().clone())),
+                Rc::new(RefCell::new(__v.1.borrow().clone())),
+            ))),
+        );
+    }
+    a0.write(__m)
 }
 
 fn f27<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: RefcountMapIter<T1, T2>,
-) -> Ptr<(Value<T1>, Value<T2>)> {
-    a0.deref()
+    a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>,
+    a1: BidirectionalIterator<(Value<T1>, Value<T2>)>,
+) -> BidirectionalIterator<(Value<T1>, Value<T2>)> {
+    a0.with_mut(|__m: &mut Map<T1, (Value<T1>, Value<T2>)>| __m.erase(&a1))
 }
 
-fn f28<T1: Ord + Clone + 'static, T2: 'static>(
-    a0: RefcountMapIter<T1, T2>,
-) -> Ptr<(Value<T1>, Value<T2>)> {
-    a0.deref()
+fn f28<T1: Ord + 'static, T2: 'static>(a0: Ptr<Map<T1, (Value<T1>, Value<T2>)>>, a1: T1) -> usize {
+    a0.with_mut(|__m: &mut Map<T1, (Value<T1>, Value<T2>)>| __m.erase_key(&a1))
 }
diff --git a/rules/map/tgt_unsafe.rs b/rules/map/tgt_unsafe.rs
index e51374694..073c0cc63 100644
--- a/rules/map/tgt_unsafe.rs
+++ b/rules/map/tgt_unsafe.rs
@@ -1,150 +1,87 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use libcc2rs::{MapIterator, UnsafeMapIterator};
-use std::collections::BTreeMap;
+use libcc2rs::*;
 
-fn t1<T1, T2>() -> BTreeMap<T1, Box<(T1, T2)>> {
-    BTreeMap::new()
-}
-
-fn t2<T1: Clone + Ord, T2>() -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::null()
-}
-
-fn t3<T1: Clone + Ord, T2>() -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::null()
+fn t1<T1, T2>() -> UnsafeMap<T1, (T1, T2)> {
+    UnsafeMap::new()
 }
 
 fn t4() -> usize {
     0_usize
 }
 
-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 f1<T1: Ord + Clone, T2: Default>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: T1) -> &mut T2 {
+    &mut (*a0.get_or_insert_with(a1.clone(), || (a1, <T2>::default()))).1
 }
-unsafe fn f2<T1, T2>(a0: BTreeMap<T1, Box<(T1, T2)>>) -> usize {
+
+unsafe fn f2<T1, T2>(a0: UnsafeMap<T1, (T1, T2)>) -> usize {
     a0.len()
 }
-unsafe fn f3<T1: Ord + Clone, T2>(
-    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
-    a1: UnsafeMapIterator<T1, T2>,
-) -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::erase(&*a0 as *const BTreeMap<T1, Box<(T1, T2)>>, &a1)
+
+unsafe fn f3<T1: Ord + Clone, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: UnsafeBidirectionalIterator<(T1, T2)>) -> UnsafeBidirectionalIterator<(T1, T2)> {
+    a0.erase(&a1)
 }
 
-unsafe fn f5<T1, T2>() -> BTreeMap<T1, Box<(T1, T2)>> {
-    BTreeMap::new()
+unsafe fn f5<T1, T2>() -> UnsafeMap<T1, (T1, T2)> {
+    UnsafeMap::new()
 }
 
-unsafe fn f6<T1: Clone, T2: Clone>(a0: BTreeMap<T1, Box<(T1, T2)>>) -> BTreeMap<T1, Box<(T1, T2)>> {
+unsafe fn f6<T1: Ord + Clone, T2: Clone>(a0: UnsafeMap<T1, (T1, T2)>) -> UnsafeMap<T1, (T1, T2)> {
     a0.clone()
 }
-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<(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<(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<(T1, T2)>>,
-    a1: T1,
-) -> UnsafeMapIterator<T1, T2> {
-    UnsafeMapIterator::find_key(&*a0 as *const BTreeMap<T1, Box<(T1, T2)>>, &a1)
-}
-unsafe fn f11<T1: PartialEq, T2: PartialEq>(
-    a0: UnsafeMapIterator<T1, T2>,
-    a1: UnsafeMapIterator<T1, T2>,
-) -> bool {
-    a0 != a1
-}
-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>,
-    a1: UnsafeMapIterator<T1, T2>,
-) -> bool {
-    a0 == a1
+unsafe fn f7<T1: Ord, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: T1) -> *const T2 {
+    &raw const (*a0.get(&a1).expect("out of range!")).1
 }
 
-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<(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 UnsafeMap<T1, (T1, T2)>, a1: T1) -> &mut T2 {
+    &mut (*a0.get_or_insert_with(a1.clone(), || (a1, <T2>::default()))).1
 }
 
-unsafe fn f16<T1: PartialEq, T2: PartialEq>(
-    a0: UnsafeMapIterator<T1, T2>,
-    a1: UnsafeMapIterator<T1, T2>,
-) -> bool {
-    a0 == 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 f9<T1, T2>(a0: UnsafeMap<T1, (T1, T2)>) -> UnsafeBidirectionalIterator<(T1, T2)> {
+    a0.end()
 }
 
-unsafe fn f19<T1: Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> UnsafeMapIterator<T1, T2> {
-    a0.clone()
+unsafe fn f10<T1: Ord, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: T1) -> UnsafeBidirectionalIterator<(T1, T2)> {
+    a0.find(&a1)
 }
 
-unsafe fn f20<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *const T1 {
-    &raw const (*a0.deref()).0
+unsafe fn f12<T1, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>) -> UnsafeBidirectionalIterator<(T1, T2)> {
+    a0.begin()
 }
-unsafe fn f21<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *mut T2 {
-    &raw mut (*a0.deref()).1
+
+unsafe fn f14<T1, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>) -> UnsafeBidirectionalIterator<(T1, T2)> {
+    a0.end()
 }
 
-unsafe fn f22<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *const T1 {
-    &raw const (*a0.deref()).0
+unsafe fn f15<T1: Ord, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: T1) -> *const T2 {
+    &raw const (*a0.get(&a1).expect("out of range!")).1
 }
-unsafe fn f23<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *mut T2 {
-    &raw mut (*a0.deref()).1
+
+unsafe fn f17<T1: Ord, T2>(a0: UnsafeMap<T1, (T1, T2)>, a1: T1) -> UnsafeBidirectionalIterator<(T1, T2)> {
+    a0.find(&a1)
 }
 
-unsafe fn f24<T1, T2>(a0: &mut BTreeMap<T1, Box<(T1, T2)>>) -> BTreeMap<T1, Box<(T1, T2)>> {
+unsafe fn f24<T1, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>) -> UnsafeMap<T1, (T1, T2)> {
     std::mem::take(&mut *a0)
 }
 
-unsafe fn f25<T1, T2>(a0: &mut BTreeMap<T1, Box<(T1, T2)>>, a1: &mut BTreeMap<T1, Box<(T1, T2)>>) {
+unsafe fn f25<T1, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: &mut UnsafeMap<T1, (T1, T2)>) {
     *a0 = std::mem::take(&mut *a1)
 }
 
-unsafe fn f26<T1: Clone, T2: Clone>(
-    a0: &mut BTreeMap<T1, Box<(T1, T2)>>,
-    a1: BTreeMap<T1, Box<(T1, T2)>>,
-) {
+unsafe fn f26<T1: Ord + Clone, T2: Clone>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: UnsafeMap<T1, (T1, T2)>) {
     *a0 = a1.clone()
 }
 
-unsafe fn f27<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *mut (T1, T2) {
-    a0.deref()
+unsafe fn f27<T1: Ord + Clone, T2>(
+    a0: &mut UnsafeMap<T1, (T1, T2)>,
+    a1: UnsafeBidirectionalIterator<(T1, T2)>,
+) -> UnsafeBidirectionalIterator<(T1, T2)> {
+    a0.erase(&a1)
 }
 
-unsafe fn f28<T1: Ord + Clone, T2>(a0: UnsafeMapIterator<T1, T2>) -> *const (T1, T2) {
-    a0.deref().cast_const()
+unsafe fn f28<T1: Ord, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: T1) -> usize {
+    a0.erase_key(&a1)
 }
diff --git a/rules/vector/src.cpp b/rules/vector/src.cpp
index f4a3cb594..684733efe 100644
--- a/rules/vector/src.cpp
+++ b/rules/vector/src.cpp
@@ -9,21 +9,10 @@
 #include <vector>
 
 #include "../common/init.h"
-#include "../common/traits.h"
 
 template <typename T1, typename T2 = std::allocator<T1>>
 using t5 = std::vector<T1, T2>;
 
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-using t6 = It;
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::const_iterator>>
-using t7 = It;
-
 template <typename T1, typename T2 = std::allocator<T1>>
 using t9 = typename std::vector<T1, T2>::size_type;
 
@@ -147,70 +136,6 @@ void f80(std::vector<T1, T2> &o, const T1 &value) {
   return o.push_back(value);
 }
 
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-typename std::vector<T1, T2>::reference f81(It it) {
-  return *it;
-}
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-typename std::vector<T1, T2>::iterator f82(const It &it) {
-  return typename std::vector<T1, T2>::iterator(it);
-}
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-typename std::vector<T1, T2>::const_iterator f83(const It &it) {
-  return typename std::vector<T1, T2>::const_iterator(it);
-}
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-typename std::vector<T1, T2>::iterator f84(It it, std::size_t n) {
-  return it + n;
-}
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-bool f85(const It &it1, const It &it2) {
-  return it1 != it2;
-}
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-bool f86(const It &it1, const It &it2) {
-  return it1 == it2;
-}
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-typename std::vector<T1, T2>::iterator f87(It a0, int a1) {
-  return a0++;
-}
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-typename std::vector<T1, T2>::iterator::difference_type f88(const It &it1,
-                                                            const It &it2) {
-  return it1 - it2;
-}
-
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::iterator>>
-typename std::vector<T1, T2>::iterator &f89(It &it) {
-  return ++it;
-}
-
 template <typename T1, typename T2 = std::allocator<T1>>
 std::vector<T1, T2> f90(const T1 *first, const T1 *last) {
   return std::vector<T1, T2>(first, last);
@@ -231,13 +156,6 @@ const T1 *f93(const std::vector<T1, T2> &o) {
   return o.data();
 }
 
-template <typename It, typename T1 = ValueOf<It>,
-          typename T2 = AllocatorOf<It, std::allocator<T1>>,
-          typename = SameAs<It, typename std::vector<T1, T2>::const_iterator>>
-typename std::vector<T1, T2>::const_iterator f94(It first, It last) {
-  return std::max_element(first, last);
-}
-
 template <typename T1, typename T2 = std::allocator<T1>>
 typename std::vector<T1, T2>::const_iterator f95(const std::vector<T1, T2> &o) {
   return o.begin();
diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs
index 5506eee6a..e4f1077f6 100644
--- a/rules/vector/tgt_refcount.rs
+++ b/rules/vector/tgt_refcount.rs
@@ -5,22 +5,14 @@ use libcc2rs::*;
 use std::cell::RefCell;
 use std::rc::Rc;
 
-fn t6<T1>() -> Ptr<T1> {
-    Ptr::null()
-}
-
-fn t7<T1>() -> Ptr<T1> {
-    Ptr::null()
-}
-
 fn f40<T1>(a0: Ptr<T1>) -> Ptr<T1> {
     a0.to_end()
 }
 
-fn f60<T1: ByteRepr>(a0: Ptr<Vec<T1>>, a1: Ptr<T1>) -> Ptr<T1> {
-    let idx = a1.get_offset();
+fn f60<T1: ByteRepr>(a0: Ptr<Vec<T1>>, a1: RandomAccessIterator<T1>) -> RandomAccessIterator<T1> {
+    let idx = a1.vec_ptr().get_offset();
     a0.with_mut(|__v: &mut Vec<T1>| __v.remove(idx));
-    a0.decay()
+    RandomAccessIterator::Vec(a0.decay())
 }
 
 fn f65<T1>(a0: Ptr<T1>) -> Ptr<T1> {
@@ -39,62 +31,26 @@ fn f69<T1>(a0: Ptr<T1>) -> Ptr<T1> {
     a0.to_last()
 }
 
-fn f72<T1>(a0: Ptr<T1>) -> Ptr<T1> {
-    a0
+fn f72<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
+    RandomAccessIterator::Vec(a0)
 }
 
-fn f76<T1>(a0: Ptr<T1>) -> Ptr<T1> {
-    a0.to_end()
+fn f76<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
+    RandomAccessIterator::Vec(a0.to_end())
 }
 
-fn f77<T1: ByteRepr>(a0: &mut Vec<T1>, a1: Ptr<T1>, a2: T1) -> Ptr<T1> {
-    let __off = a1.get_offset();
+fn f77<T1: ByteRepr>(a0: &mut Vec<T1>, a1: RandomAccessIterator<T1>, a2: T1) -> RandomAccessIterator<T1> {
+    let __off = a1.vec_ptr().get_offset();
     a0.insert(__off, a2);
     a1
 }
 
-fn f79<T1: ByteRepr>(a0: &mut Vec<T1>, a1: Ptr<T1>, a2: T1) -> Ptr<T1> {
-    let __off = a1.get_offset();
+fn f79<T1: ByteRepr>(a0: &mut Vec<T1>, a1: RandomAccessIterator<T1>, a2: T1) -> RandomAccessIterator<T1> {
+    let __off = a1.vec_ptr().get_offset();
     a0.insert(__off, a2);
     a1
 }
 
-fn f81<T1>(a0: Ptr<T1>) -> Ptr<T1> {
-    a0
-}
-
-fn f82<T1>(a0: Ptr<T1>) -> Ptr<T1> {
-    a0
-}
-
-fn f83<T1>(a0: Ptr<T1>) -> Ptr<T1> {
-    a0
-}
-
-fn f84<T1>(a0: Ptr<T1>, a1: usize) -> Ptr<T1> {
-    a0.offset(a1 as isize)
-}
-
-fn f85<T1>(a0: Ptr<T1>, a1: Ptr<T1>) -> bool {
-    a0 != a1
-}
-
-fn f86<T1>(a0: Ptr<T1>, a1: Ptr<T1>) -> bool {
-    a0 == a1
-}
-
-fn f87<T1>(a0: &mut Ptr<T1>) -> Ptr<T1> {
-    a0.postfix_inc()
-}
-
-fn f88<T1>(a0: Ptr<T1>, a1: Ptr<T1>) -> isize {
-    ((a0.get_offset() as isize) - (a1.get_offset() as isize))
-}
-
-fn f89<T1>(a0: &mut Ptr<T1>) -> Ptr<T1> {
-    a0.prefix_inc()
-}
-
 fn f90<T1: Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) -> Vec<T1> {
     let __count = a1.get_offset() - a0.get_offset();
     PtrValueIter::new(&a0, __count).collect::<Vec<_>>()
@@ -111,25 +67,12 @@ fn f93<T1>(a0: Ptr<T1>) -> Ptr<T1> {
     a0
 }
 
-fn f94(a0: Ptr<u8>, a1: Ptr<u8>) -> Ptr<u8> {
-    let __count = a1.get_offset() - a0.get_offset();
-    let max_index = PtrValueIter::new(&a0, __count)
-        .enumerate()
-        .max_by(|&(idx_a, val_a), &(idx_b, val_b)| {
-            val_a.cmp(&val_b).then_with(|| idx_b.cmp(&idx_a))
-        })
-        .map(|(idx, _)| idx)
-        .unwrap_or(0);
-
-    a0 + max_index
-}
-
-fn f95<T1>(a0: Ptr<T1>) -> Ptr<T1> {
-    a0
+fn f95<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
+    RandomAccessIterator::Vec(a0)
 }
 
-fn f96<T1>(a0: Ptr<T1>) -> Ptr<T1> {
-    a0.to_end()
+fn f96<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
+    RandomAccessIterator::Vec(a0.to_end())
 }
 
 fn f98<T1: ByteRepr>(a0: Ptr<Vec<T1>>, a1: usize) -> Ptr<Vec<T1>> {
@@ -146,25 +89,25 @@ fn f99<T1>(a0: Ptr<T1>) -> Ptr<T1> {
 
 fn f101<T1: Clone + ByteRepr>(
     a0: Ptr<Vec<T1>>,
-    a1: Ptr<T1>,
+    a1: RandomAccessIterator<T1>,
     a2: Ptr<T1>,
     a3: Ptr<T1>,
-) -> Ptr<Vec<T1>> {
-    let start_idx = a1.get_offset();
+) -> RandomAccessIterator<T1> {
+    let start_idx = a1.vec_ptr().get_offset();
     let count = a3.get_offset() - a2.get_offset();
     let temp_vec: Vec<T1> = PtrValueIter::new(&a2, count).collect();
     a0.with_mut(|v: &mut Vec<T1>| {
         v.splice(start_idx..start_idx, temp_vec);
     });
-    a0 + start_idx
+    RandomAccessIterator::Vec(a0.decay() + start_idx)
 }
 
 fn f103<T1: ByteRepr + Clone>(a0: Ptr<Vec<T1>>, a1: &mut Vec<T1>) {
     a0.write(std::mem::take(&mut *a1))
 }
 
-fn f104<T1>(a0: Ptr<T1>) -> Ptr<T1> {
-    a0.to_end()
+fn f104<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
+    RandomAccessIterator::Vec(a0.to_end())
 }
 
 fn f105<T1: Clone + ByteRepr>(a0: Ptr<Vec<T1>>, a1: Vec<T1>) {
diff --git a/rules/vector/tgt_unsafe.rs b/rules/vector/tgt_unsafe.rs
index 88e469248..d8c5fa4b2 100644
--- a/rules/vector/tgt_unsafe.rs
+++ b/rules/vector/tgt_unsafe.rs
@@ -7,14 +7,6 @@ fn t5<T1>() -> Vec<T1> {
     Default::default()
 }
 
-fn t6<T1>() -> *mut T1 {
-    Default::default()
-}
-
-fn t7<T1>() -> *const T1 {
-    Default::default()
-}
-
 fn t9() -> usize {
     0_usize
 }
@@ -31,8 +23,8 @@ unsafe fn f47(a0: Vec<bool>) -> Vec<bool> {
     a0
 }
 
-unsafe fn f60<T1>(a0: &mut Vec<T1>, a1: *const T1) -> *const T1 {
-    let pos = a1.offset_from(a0.as_ptr()) as usize;
+unsafe fn f60<T1>(a0: &mut Vec<T1>, a1: UnsafeRandomAccessIterator<T1>) -> UnsafeRandomAccessIterator<T1> {
+    let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize;
     a0.remove(pos);
     a1
 }
@@ -86,8 +78,8 @@ unsafe fn f71<T1>(a0: &mut Vec<T1>, a1: usize) {
     }
 }
 
-unsafe fn f72<T1>(a0: &mut Vec<T1>) -> *mut T1 {
-    a0.as_mut_ptr()
+unsafe fn f72<T1>(a0: &mut Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
+    UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())
 }
 
 unsafe fn f73<T1: Default>(a0: &mut Vec<T1>, a1: &mut T1) {
@@ -104,22 +96,24 @@ unsafe fn f75<T1>(a0: &mut Vec<T1>) {
     a0.clear()
 }
 
-unsafe fn f76<T1>(a0: &mut Vec<T1>) -> *mut T1 {
-    a0.as_mut_ptr().add(a0.len())
+unsafe fn f76<T1>(a0: &mut Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
+    UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(a0.len()))
 }
 
-unsafe fn f77<T1>(a0: &mut Vec<T1>, a1: *const T1, a2: T1) {
-    let pos = a1.offset_from(a0.as_ptr()) as usize;
+unsafe fn f77<T1>(a0: &mut Vec<T1>, a1: UnsafeRandomAccessIterator<T1>, a2: T1) -> UnsafeRandomAccessIterator<T1> {
+    let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize;
     a0.insert(pos, a2);
+    a1
 }
 
 unsafe fn f78<T1: Default + Clone>(a0: usize, a1: T1) -> Vec<T1> {
     vec![a1; a0 as usize]
 }
 
-unsafe fn f79<T1>(a0: &mut Vec<T1>, a1: *const T1, a2: T1) {
-    let pos = a1.offset_from(a0.as_ptr()) as usize;
+unsafe fn f79<T1>(a0: &mut Vec<T1>, a1: UnsafeRandomAccessIterator<T1>, a2: T1) -> UnsafeRandomAccessIterator<T1> {
+    let pos = a1.vec_ptr().offset_from(a0.as_ptr()) as usize;
     a0.insert(pos, a2);
+    a1
 }
 
 unsafe fn f80<T1: Clone>(a0: &mut Vec<T1>, a1: T1) {
@@ -127,41 +121,6 @@ unsafe fn f80<T1: Clone>(a0: &mut Vec<T1>, a1: T1) {
     a0.push(a0_clone)
 }
 
-unsafe fn f81<T1>(a0: *mut T1) -> *mut T1 {
-    a0
-}
-
-unsafe fn f82<T1>(a0: *const T1) -> *const T1 {
-    a0
-}
-
-unsafe fn f83<T1>(a0: *const T1) -> *const T1 {
-    a0
-}
-
-unsafe fn f84<T1>(a0: *mut T1, a1: usize) -> *mut T1 {
-    a0.add(a1 as usize)
-}
-
-unsafe fn f85<T1>(a0: *const T1, a1: *const T1) -> bool {
-    a0 != a1
-}
-unsafe fn f86<T1>(a0: *const T1, a1: *const T1) -> bool {
-    a0 == a1
-}
-
-unsafe fn f87<T1>(a0: &mut *mut T1) -> *mut T1 {
-    a0.postfix_inc()
-}
-
-unsafe fn f88<T1>(a0: *const T1, a1: *const T1) -> isize {
-    a0.offset_from(a1)
-}
-
-unsafe fn f89<T1>(a0: &mut *mut T1) -> *mut T1 {
-    a0.prefix_inc()
-}
-
 unsafe fn f90<T1: Clone>(a0: *const T1, a1: *const T1) -> Vec<T1> {
     core::slice::from_raw_parts(a0, (a1).offset_from(a0) as usize).to_vec()
 }
@@ -181,21 +140,12 @@ unsafe fn f93<T1>(a0: &mut Vec<T1>) -> *const T1 {
     a0.as_ptr()
 }
 
-unsafe fn f94<T1: Ord>(a0: *const T1, a1: *const T1) -> *const T1 {
-    core::slice::from_raw_parts(a0, (a1).offset_from(a0) as usize)
-        .iter()
-        .enumerate()
-        .max_by(|(idx_a, val_a), (idx_b, val_b)| val_a.cmp(val_b).then_with(|| idx_b.cmp(idx_a)))
-        .map(|(_, value)| value)
-        .unwrap()
+unsafe fn f95<T1>(a0: Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
+    UnsafeRandomAccessIterator::Vec(a0.as_ptr().cast_mut())
 }
 
-unsafe fn f95<T1>(a0: Vec<T1>) -> *const T1 {
-    a0.as_ptr()
-}
-
-unsafe fn f96<T1>(a0: Vec<T1>) -> *const T1 {
-    a0.as_ptr().add(a0.len())
+unsafe fn f96<T1>(a0: Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
+    UnsafeRandomAccessIterator::Vec(a0.as_ptr().add(a0.len()).cast_mut())
 }
 
 unsafe fn f97(a0: &mut Vec<bool>, a1: &mut Vec<bool>) {
@@ -216,17 +166,17 @@ unsafe fn f99<T1>(a0: &Vec<T1>) -> &T1 {
 
 unsafe fn f101<T1: Clone>(
     a0: &mut Vec<T1>,
-    a1: *const T1,
+    a1: UnsafeRandomAccessIterator<T1>,
     a2: *const T1,
     a3: *const T1,
-) -> *mut T1 {
-    let __off = a1.offset_from(a0.as_ptr()) as usize;
+) -> UnsafeRandomAccessIterator<T1> {
+    let __off = a1.vec_ptr().offset_from(a0.as_ptr()) as usize;
     let count = a3.offset_from(a2) as usize;
     a0.splice(
         __off..__off,
         std::slice::from_raw_parts(a2, count).iter().cloned(),
     );
-    a0.as_mut_ptr().add(__off)
+    UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(__off))
 }
 
 unsafe fn f102<T1: Default + Clone>(a0: &mut Vec<T1>, a1: usize, a2: T1) {
@@ -238,8 +188,8 @@ unsafe fn f103<T1: Clone>(a0: &mut Vec<T1>, a1: &mut Vec<T1>) {
     *a0 = std::mem::take(&mut *a1)
 }
 
-unsafe fn f104<T1>(a0: Vec<T1>) -> *const T1 {
-    a0.as_ptr().add(a0.len())
+unsafe fn f104<T1>(a0: Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
+    UnsafeRandomAccessIterator::Vec(a0.as_ptr().add(a0.len()).cast_mut())
 }
 
 unsafe fn f105<T1: Clone>(a0: &mut Vec<T1>, a1: Vec<T1>) {
diff --git a/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs b/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs
index 98370becb..dea049e02 100644
--- a/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs
+++ b/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs
@@ -15,7 +15,8 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 2]));
-    let b: Ptr<i32> = ({ foo_0((v.as_pointer() as Ptr<i32>)) });
+    let b: Ptr<i32> =
+        ({ foo_0(RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)).iter_deref()) });
     (*v.borrow_mut()).clear();
     return (b.read());
 }
diff --git a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
index c8d8a40f6..2abcddf6e 100644
--- a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
+++ b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
@@ -17,7 +17,8 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut v: Vec<i32> = vec![1, 2];
-    let b: *const i32 = (unsafe { foo_0(&(*v.as_mut_ptr())) });
+    let b: *const i32 =
+        (unsafe { foo_0(&(*UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_deref())) });
     v.clear();
     return (*b);
 }
diff --git a/tests/unit/map.cpp b/tests/unit/map.cpp
index c8ab28041..e696c65a2 100644
--- a/tests/unit/map.cpp
+++ b/tests/unit/map.cpp
@@ -58,6 +58,21 @@ int main() {
   r.erase(it4);
   assert(r.size() == 3);
   assert(m.find(4) == m.end());
+  m[7] = 7;
+  m[8] = 8;
+  m[9] = 9;
+  assert(r.size() == 6);
+  assert(m.erase(10) == 0);
+  int key9 = 9;
+  assert(m.erase(key9) == 1);
+  assert(r.size() == 5);
+  std::map<short, unsigned>::const_iterator cit = m.find(7);
+  std::map<short, unsigned>::iterator next = m.erase(cit);
+  assert(next == m.find(8));
+  next = m.erase(next);
+  assert(next == m.end());
+  assert(r.size() == 3);
+  assert(m.find(8) == m.end());
   std::map<std::pair<int, long>, double> other_map;
   assert(other_map.size() == 0);
   std::pair<int, long> key0(1, 1);
diff --git a/tests/unit/out/refcount/clone_vs_move.rs b/tests/unit/out/refcount/clone_vs_move.rs
index c1d84d632..1352f5f23 100644
--- a/tests/unit/out/refcount/clone_vs_move.rs
+++ b/tests/unit/out/refcount/clone_vs_move.rs
@@ -255,73 +255,68 @@ fn main_0() -> i32 {
         }
         i.prefix_inc();
     }
-    let map1: Value<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>> =
-        Rc::new(RefCell::new(BTreeMap::new()));
+    let map1: Value<Map<i32, (Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(Map::new()));
     let mut i: i32 = 0;
     'loop_: while (i < N) {
         let __rhs = i;
-        (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()
+        (map1.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+                __m.get_or_insert_with(i.clone(), || {
+                    (
+                        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<(Value<i32>, Value<i32>)>>> = Rc::new(RefCell::new(
-        (*map1.borrow())
-            .iter()
-            .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 map2: Value<Map<i32, (Value<i32>, Value<i32>)>> = Rc::new(RefCell::new({
+        let mut __m = Map::new();
+        for (__k, __v) in (*map1.borrow()).entries() {
+            let __v = __v.borrow();
+            __m.insert(
+                __k.clone(),
+                Rc::new(RefCell::new((
+                    Rc::new(RefCell::new(__v.0.borrow().clone())),
+                    Rc::new(RefCell::new(__v.1.borrow().clone())),
+                ))),
+            );
+        }
+        __m
+    }));
     let mut i: i32 = 0;
     'loop_: while (i < N) {
         assert!(
-            (((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<(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((
+            (((map2.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+                .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+                    __m.get_or_insert_with(i.clone(), || {
+                        (
                             Rc::new(RefCell::new(i)),
                             Rc::new(RefCell::new(<i32>::default())),
-                        )))
+                        )
                     })
                     .borrow()
                     .1
                     .as_pointer()
+                })
+                .read())
+                == i)
+        );
+        (map2.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+                __m.get_or_insert_with(i.clone(), || {
+                    (
+                        Rc::new(RefCell::new(i)),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )
+                })
+                .borrow()
+                .1
+                .as_pointer()
             })
             .with_mut(|__v| __v.prefix_inc());
         i.prefix_inc();
@@ -329,35 +324,33 @@ fn main_0() -> i32 {
     let mut i: i32 = 0;
     'loop_: while (i < N) {
         assert!(
-            (((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()
+            (((map1.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+                .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+                    __m.get_or_insert_with(i.clone(), || {
+                        (
+                            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<(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()
+            (((map2.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+                .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+                    __m.get_or_insert_with(i.clone(), || {
+                        (
+                            Rc::new(RefCell::new(i)),
+                            Rc::new(RefCell::new(<i32>::default())),
+                        )
+                    })
+                    .borrow()
+                    .1
+                    .as_pointer()
                 })
                 .read())
                 == (i + 1))
diff --git a/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs b/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs
index cda73dcf7..60352aa1a 100644
--- a/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs
+++ b/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs
@@ -20,20 +20,17 @@ fn main_0() -> i32 {
         let __a1 = 7;
         (*v.borrow_mut()).push(__a1)
     };
-    let mut it: Ptr<i32> = {
-        let count = ((v.as_pointer() as Ptr<i32>).to_end().get_offset()
-            - (v.as_pointer() as Ptr<i32>).get_offset()) as usize;
-        (v.as_pointer() as Ptr<i32>).offset(
-            (v.as_pointer() as Ptr<i32>)
-                .clone()
-                .into_iter()
-                .take(count)
-                .position(|value_0| value_0.read() == 7)
-                .unwrap_or(count) as isize,
-        )
-    };
-    assert!(it != (v.as_pointer() as Ptr<i32>).to_end());
-    assert!(((it.read()) == 7));
+    let it: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new({
+        let mut __it = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>));
+        while __it != RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end())
+            && __it.iter_deref().with(|__v| *__v != 7)
+        {
+            __it.iter_inc();
+        }
+        __it
+    }));
+    assert!((*it.borrow()) != RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end()));
+    assert!((((*it.borrow()).iter_deref().read()) == 7));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/find.rs b/tests/unit/out/refcount/find.rs
index b5c5d4a0d..de56d1695 100644
--- a/tests/unit/out/refcount/find.rs
+++ b/tests/unit/out/refcount/find.rs
@@ -24,140 +24,118 @@ fn main_0() -> i32 {
         let __a1 = 3;
         (*v.borrow_mut()).push(__a1)
     };
-    let mut v_begin: Ptr<i32> = (v.as_pointer() as Ptr<i32>);
-    let mut v_end: Ptr<i32> = (v.as_pointer() as Ptr<i32>).to_end();
-    let mut it: Ptr<i32> = {
-        let count = (v_end.get_offset() - v_begin.get_offset()) as usize;
-        v_begin.offset(
-            v_begin
-                .clone()
-                .into_iter()
-                .take(count)
-                .position(|value_0| value_0.read() == 2)
-                .unwrap_or(count) as isize,
-        )
-    };
-    let mut v_result_true: bool = it != (v.as_pointer() as Ptr<i32>).to_end();
-    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()
+    let v_begin: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(
+        RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)),
+    ));
+    let v_end: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(RandomAccessIterator::Vec(
+        (v.as_pointer() as Ptr<i32>).to_end(),
+    )));
+    let it: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new({
+        let mut __it = (*v_begin.borrow()).clone();
+        while __it != (*v_end.borrow()).clone() && __it.iter_deref().with(|__v| *__v != 2) {
+            __it.iter_inc();
+        }
+        __it
+    }));
+    let mut v_result_true: bool =
+        (*it.borrow()) != RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end());
+    let m: Value<Map<i32, (Value<i32>, Value<f64>)>> = Rc::new(RefCell::new(Map::new()));
+    (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+        .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<f64>)>| {
+            __m.get_or_insert_with(1.clone(), || {
+                (
+                    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<(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()
+    (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+        .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<f64>)>| {
+            __m.get_or_insert_with(2.clone(), || {
+                (
+                    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<(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()
+    (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+        .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<f64>)>| {
+            __m.get_or_insert_with(3.clone(), || {
+                (
+                    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<(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<(Value<i32>, Value<f64>)>>>),
-    )));
+    let m_begin: Value<BidirectionalIterator<(Value<i32>, Value<f64>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.begin()),
+    ));
+    let m_end: Value<BidirectionalIterator<(Value<i32>, Value<f64>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.end()),
+    ));
     let mut m_result_true: bool = (*m_begin.borrow()) != (*m_end.borrow());
     assert!(
         ((v_result_true) && (m_result_true))
             && ({
-                let count = ((v.as_pointer() as Ptr<i32>).get_offset()
-                    - (v.as_pointer() as Ptr<i32>).get_offset())
-                    as usize;
-                (v.as_pointer() as Ptr<i32>).offset(
-                    (v.as_pointer() as Ptr<i32>)
-                        .clone()
-                        .into_iter()
-                        .take(count)
-                        .position(|value_0| value_0.read() == 2)
-                        .unwrap_or(count) as isize,
-                )
-            } == (v.as_pointer() as Ptr<i32>))
+                let mut __it = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>));
+                while __it != RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+                    && __it.iter_deref().with(|__v| *__v != 2)
+                {
+                    __it.iter_inc();
+                }
+                __it
+            } == RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)))
     );
     let w: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 2, 3, 4, 5]));
     assert!(
         {
-            let count = ((w.as_pointer() as Ptr<i32>).to_end().get_offset()
-                - (w.as_pointer() as Ptr<i32>)
-                    .offset(2_i64 as isize)
-                    .get_offset()) as usize;
-            (w.as_pointer() as Ptr<i32>).offset(2_i64 as isize).offset(
-                (w.as_pointer() as Ptr<i32>)
-                    .offset(2_i64 as isize)
-                    .clone()
-                    .into_iter()
-                    .take(count)
-                    .position(|value_0| value_0.read() == 4)
-                    .unwrap_or(count) as isize,
-            )
-        } == (w.as_pointer() as Ptr<i32>).offset(3_i64 as isize)
+            let mut __it =
+                RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>)).iter_add(2_isize);
+            while __it != RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>).to_end())
+                && __it.iter_deref().with(|__v| *__v != 4)
+            {
+                __it.iter_inc();
+            }
+            __it
+        } == RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>)).iter_add(3_isize)
     );
     assert!(
         {
-            let count = ((w.as_pointer() as Ptr<i32>).to_end().get_offset()
-                - (w.as_pointer() as Ptr<i32>)
-                    .offset(2_i64 as isize)
-                    .get_offset()) as usize;
-            (w.as_pointer() as Ptr<i32>).offset(2_i64 as isize).offset(
-                (w.as_pointer() as Ptr<i32>)
-                    .offset(2_i64 as isize)
-                    .clone()
-                    .into_iter()
-                    .take(count)
-                    .position(|value_0| value_0.read() == 1)
-                    .unwrap_or(count) as isize,
-            )
-        } == (w.as_pointer() as Ptr<i32>).to_end()
+            let mut __it =
+                RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>)).iter_add(2_isize);
+            while __it != RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>).to_end())
+                && __it.iter_deref().with(|__v| *__v != 1)
+            {
+                __it.iter_inc();
+            }
+            __it
+        } == RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>).to_end())
     );
     assert!(
         {
-            let count = ((w.as_pointer() as Ptr<i32>)
-                .offset(4_i64 as isize)
-                .get_offset()
-                - (w.as_pointer() as Ptr<i32>)
-                    .offset(2_i64 as isize)
-                    .get_offset()) as usize;
-            (w.as_pointer() as Ptr<i32>).offset(2_i64 as isize).offset(
-                (w.as_pointer() as Ptr<i32>)
-                    .offset(2_i64 as isize)
-                    .clone()
-                    .into_iter()
-                    .take(count)
-                    .position(|value_0| value_0.read() == 5)
-                    .unwrap_or(count) as isize,
-            )
-        } == (w.as_pointer() as Ptr<i32>).offset(4_i64 as isize)
+            let mut __it =
+                RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>)).iter_add(2_isize);
+            while __it != RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>)).iter_add(4_isize)
+                && __it.iter_deref().with(|__v| *__v != 5)
+            {
+                __it.iter_inc();
+            }
+            __it
+        } == RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>)).iter_add(4_isize)
     );
     return 0;
 }
diff --git a/tests/unit/out/refcount/fn_ptr_stable_sort.rs b/tests/unit/out/refcount/fn_ptr_stable_sort.rs
index c889c691a..6e40e5a33 100644
--- a/tests/unit/out/refcount/fn_ptr_stable_sort.rs
+++ b/tests/unit/out/refcount/fn_ptr_stable_sort.rs
@@ -35,10 +35,35 @@ fn main_0() -> i32 {
         let __a1 = Item { key: 2, value: 20 };
         (*v.borrow_mut()).push(__a1)
     };
-    (v.as_pointer() as Ptr<Item>).sort_with_cmp(
-        (v.as_pointer() as Ptr<Item>).to_end().get_offset(),
-        |x, y| Compare_0.call(x, y),
-    );
+    {
+        let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>).to_end())
+            .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>)));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            let __a = RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>)).iter_at(__x);
+            let __b = RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>)).iter_at(__y);
+            if Compare_0.call(__a.clone(), __b.clone()) {
+                std::cmp::Ordering::Less
+            } else if Compare_0.call(__b, __a) {
+                std::cmp::Ordering::Greater
+            } else {
+                std::cmp::Ordering::Equal
+            }
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>))
+                    .iter_at(__i)
+                    .read()
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>))
+                .iter_at(__i)
+                .write(__v);
+        }
+    };
     assert!(({ (*v.borrow())[0_usize].key } == 1));
     assert!(({ (*v.borrow())[1_usize].key } == 2));
     assert!(({ (*v.borrow())[2_usize].key } == 3));
diff --git a/tests/unit/out/refcount/foreach_map.rs b/tests/unit/out/refcount/foreach_map.rs
index 330c91602..6ded20983 100644
--- a/tests/unit/out/refcount/foreach_map.rs
+++ b/tests/unit/out/refcount/foreach_map.rs
@@ -11,23 +11,21 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let m: Value<BTreeMap<i32, Value<(Value<i32>, Value<f64>)>>> =
-        Rc::new(RefCell::new(BTreeMap::new()));
+    let m: Value<Map<i32, (Value<i32>, Value<f64>)>> = Rc::new(RefCell::new(Map::new()));
     let mut i: i32 = 0;
     let mut k: i32 = 100;
     'loop_: while (i < 100) {
-        (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()
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<f64>)>| {
+                __m.get_or_insert_with(i.clone(), || {
+                    (
+                        Rc::new(RefCell::new(i)),
+                        Rc::new(RefCell::new(<f64>::default())),
+                    )
+                })
+                .borrow()
+                .1
+                .as_pointer()
             })
             .write(((k as f64) / 2_f64));
         {
@@ -36,22 +34,24 @@ fn main_0() -> i32 {
         };
     }
     let mut sum: f64 = 0_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();
+    'loop_: for __begin1 in Map::range(m.as_pointer()) {
+        let __begin1: Value<BidirectionalIterator<(Value<i32>, Value<f64>)>> =
+            Rc::new(RefCell::new(__begin1));
+        let i: Ptr<(Value<i32>, Value<f64>)> = (*__begin1.borrow()).iter_deref();
         sum += (*(*i.upgrade().deref()).1.borrow());
     }
-    'loop_: for __begin1 in RefcountMapIter::begin(m.as_pointer()) {
-        let __begin1: Value<RefcountMapIter<i32, f64>> = Rc::new(RefCell::new(__begin1));
+    'loop_: for __begin1 in Map::range(m.as_pointer()) {
+        let __begin1: Value<BidirectionalIterator<(Value<i32>, Value<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())
+                (*(*__begin1.borrow()).iter_deref().upgrade().deref())
                     .0
                     .borrow()
                     .clone(),
             )),
             Rc::new(RefCell::new(
-                (*(*__begin1.borrow()).deref().upgrade().deref())
+                (*(*__begin1.borrow()).iter_deref().upgrade().deref())
                     .1
                     .borrow()
                     .clone(),
@@ -60,17 +60,18 @@ fn main_0() -> i32 {
         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));
+    'loop_: for __begin1 in Map::range(m.as_pointer()) {
+        let __begin1: Value<BidirectionalIterator<(Value<i32>, Value<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())
+                (*(*__begin1.borrow()).iter_deref().upgrade().deref())
                     .0
                     .borrow()
                     .clone(),
             )),
             Rc::new(RefCell::new(
-                (*(*__begin1.borrow()).deref().upgrade().deref())
+                (*(*__begin1.borrow()).iter_deref().upgrade().deref())
                     .1
                     .borrow()
                     .clone(),
@@ -79,9 +80,10 @@ fn main_0() -> i32 {
         (*(*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();
+    'loop_: for __begin1 in Map::range(m.as_pointer()) {
+        let __begin1: Value<BidirectionalIterator<(Value<i32>, Value<f64>)>> =
+            Rc::new(RefCell::new(__begin1));
+        let i: Ptr<(Value<i32>, Value<f64>)> = (*__begin1.borrow()).iter_deref();
         assert!(((*(*i.upgrade().deref()).1.borrow()) != (-1_i32 as f64)));
     }
     return 0;
diff --git a/tests/unit/out/refcount/inet_pton_ntop.rs b/tests/unit/out/refcount/inet_pton_ntop.rs
index f62541cec..b8ca2ddcb 100644
--- a/tests/unit/out/refcount/inet_pton_ntop.rs
+++ b/tests/unit/out/refcount/inet_pton_ntop.rs
@@ -14,16 +14,16 @@ pub fn test_s6_addr_access_0() {
     let addr: Value<libcc2rs::In6Addr> = Rc::new(RefCell::new(Default::default()));
     let mut ap: Ptr<libcc2rs::In6Addr> = (addr.as_pointer());
     {
-        ((In6Addr::s6_addr(addr.as_pointer()) as Ptr<u8>) as Ptr<u8>)
+        ((In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr<u8>) as Ptr<u8>)
             .to_any()
             .memcpy(
                 &((loopback.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
                 16_usize as usize,
             );
-        ((In6Addr::s6_addr(addr.as_pointer()) as Ptr<u8>) as Ptr<u8>).to_any()
+        ((In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr<u8>) as Ptr<u8>).to_any()
     };
     assert!(
-        (((((In6Addr::s6_addr((ap).clone()) as Ptr::<u8>) as Ptr<u8>)
+        (((((In6Addr::s6_addr(((ap).clone() as Ptr<In6Addr>)) as Ptr::<u8>) as Ptr<u8>)
             .to_any()
             .memcmp(
                 &((loopback.as_pointer() as Ptr::<u8>) as Ptr<u8>).to_any(),
@@ -32,50 +32,93 @@ pub fn test_s6_addr_access_0() {
             == 0) as i32)
             != 0)
     );
-    elem!((In6Addr::s6_addr(addr.as_pointer()) as Ptr::<u8>), 0).write(32_u8);
-    elem!((In6Addr::s6_addr((ap).clone()) as Ptr::<u8>), 1).write(1_u8);
+    elem!(
+        (In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr::<u8>),
+        0
+    )
+    .write(32_u8);
+    elem!(
+        (In6Addr::s6_addr(((ap).clone() as Ptr<In6Addr>)) as Ptr::<u8>),
+        1
+    )
+    .write(1_u8);
     assert!(
-        ((((((((elem!((In6Addr::s6_addr(addr.as_pointer()) as Ptr::<u8>), 0).read()) as i32) == 32)
-            as i32)
+        ((((((((elem!(
+            (In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr::<u8>),
+            0
+        )
+        .read()) as i32)
+            == 32) as i32)
             != 0)
-            && (((((elem!((In6Addr::s6_addr((ap).clone()) as Ptr::<u8>), 1).read()) as i32) == 1)
-                as i32)
+            && (((((elem!(
+                (In6Addr::s6_addr(((ap).clone() as Ptr<In6Addr>)) as Ptr::<u8>),
+                1
+            )
+            .read()) as i32)
+                == 1) as i32)
                 != 0)) as i32)
             != 0)
     );
-    elem!((In6Addr::s6_addr(addr.as_pointer()) as Ptr::<u8>), 15).write({
-        (((elem!((In6Addr::s6_addr(addr.as_pointer()) as Ptr::<u8>), 15).read()) as i32) + 4) as u8
+    elem!(
+        (In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr::<u8>),
+        15
+    )
+    .write({
+        (((elem!(
+            (In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr::<u8>),
+            15
+        )
+        .read()) as i32)
+            + 4) as u8
     });
-    elem!((In6Addr::s6_addr((ap).clone()) as Ptr::<u8>), 15).with_mut(|__v| __v.postfix_inc());
+    elem!(
+        (In6Addr::s6_addr(((ap).clone() as Ptr<In6Addr>)) as Ptr::<u8>),
+        15
+    )
+    .with_mut(|__v| __v.postfix_inc());
     assert!(
-        (((((elem!((In6Addr::s6_addr(addr.as_pointer()) as Ptr::<u8>), 15).read()) as i32) == 6)
-            as i32)
+        (((((elem!(
+            (In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr::<u8>),
+            15
+        )
+        .read()) as i32)
+            == 6) as i32)
             != 0)
     );
-    let mut bytes: Ptr<u8> = (In6Addr::s6_addr(addr.as_pointer()) as Ptr<u8>);
+    let mut bytes: Ptr<u8> = (In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr<u8>);
     elem!(bytes, 2).write(7_u8);
     assert!(
-        (((((elem!((In6Addr::s6_addr((ap).clone()) as Ptr::<u8>), 2).read()) as i32) == 7) as i32)
+        (((((elem!(
+            (In6Addr::s6_addr(((ap).clone() as Ptr<In6Addr>)) as Ptr::<u8>),
+            2
+        )
+        .read()) as i32)
+            == 7) as i32)
             != 0)
     );
-    let mut fourth: Ptr<u8> = ((In6Addr::s6_addr((ap).clone()) as Ptr<u8>).offset((3) as isize));
+    let mut fourth: Ptr<u8> =
+        ((In6Addr::s6_addr(((ap).clone() as Ptr<In6Addr>)) as Ptr<u8>).offset((3) as isize));
     fourth.write(8_u8);
     assert!(
-        (((((elem!((In6Addr::s6_addr(addr.as_pointer()) as Ptr::<u8>), 3).read()) as i32) == 8)
-            as i32)
+        (((((elem!(
+            (In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr::<u8>),
+            3
+        )
+        .read()) as i32)
+            == 8) as i32)
             != 0)
     );
     {
-        ((In6Addr::s6_addr((ap).clone()) as Ptr<u8>) as Ptr<u8>)
+        ((In6Addr::s6_addr(((ap).clone() as Ptr<In6Addr>)) as Ptr<u8>) as Ptr<u8>)
             .to_any()
             .memcpy(
                 &((loopback.as_pointer() as Ptr<u8>) as Ptr<u8>).to_any(),
                 16_usize as usize,
             );
-        ((In6Addr::s6_addr((ap).clone()) as Ptr<u8>) as Ptr<u8>).to_any()
+        ((In6Addr::s6_addr(((ap).clone() as Ptr<In6Addr>)) as Ptr<u8>) as Ptr<u8>).to_any()
     };
     assert!(
-        (((((In6Addr::s6_addr(addr.as_pointer()) as Ptr::<u8>) as Ptr<u8>)
+        (((((In6Addr::s6_addr((addr.as_pointer() as Ptr<In6Addr>)) as Ptr::<u8>) as Ptr<u8>)
             .to_any()
             .memcmp(
                 &((loopback.as_pointer() as Ptr::<u8>) as Ptr<u8>).to_any(),
diff --git a/tests/unit/out/refcount/iterator_freshness.rs b/tests/unit/out/refcount/iterator_freshness.rs
index eb8ec13c8..48f08d0bf 100644
--- a/tests/unit/out/refcount/iterator_freshness.rs
+++ b/tests/unit/out/refcount/iterator_freshness.rs
@@ -6,7 +6,9 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-pub fn foo_0(mut a0: Ptr<i32>) {}
+pub fn foo_0(a0: RandomAccessIterator<i32>) {
+    let a0: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(a0));
+}
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -17,8 +19,10 @@ fn main_0() -> i32 {
             .map(|_| <i32>::default())
             .collect::<Vec<_>>(),
     ));
-    let mut it: Ptr<i32> = (vec_.as_pointer() as Ptr<i32>);
-    ({ foo_0((it).clone()) });
+    let it: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(RandomAccessIterator::Vec(
+        (vec_.as_pointer() as Ptr<i32>),
+    )));
+    ({ foo_0((*it.borrow()).clone()) });
     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 53c22cf71..114d64aab 100644
--- a/tests/unit/out/refcount/map-reallocation.rs
+++ b/tests/unit/out/refcount/map-reallocation.rs
@@ -13,33 +13,30 @@ pub fn main() {
 fn main_0() -> i32 {
     let mut N: i32 = 10000;
     let mut sentinel: i32 = (N / 2);
-    let m: Value<BTreeMap<i32, Value<(Value<i32>, Value<i32>)>>> =
-        Rc::new(RefCell::new(BTreeMap::new()));
+    let m: Value<Map<i32, (Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(Map::new()));
     let __rhs = sentinel;
-    (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()
+    (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+        .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+            __m.get_or_insert_with(sentinel.clone(), || {
+                (
+                    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<(Value<i32>, Value<i32>)>>>),
-        &sentinel,
-    )));
-    let mut p: Ptr<i32> = ((*it.borrow())
-        .deref()
-        .with(|__p| __p.1.clone())
+    let it: Value<BidirectionalIterator<(Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.find(&sentinel)),
+    ));
+    let mut p: Ptr<i32> = ((*(*it.borrow()).iter_deref().upgrade().deref())
+        .1
         .as_pointer());
     assert!(
-        ((*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow()) == sentinel)
+        ((*(*(*it.borrow()).iter_deref().upgrade().deref()).1.borrow()) == sentinel)
             && (!(Ptr::<i8>::from_string_literal(
                 b"iterator does not have correct value before insert"
             ))
@@ -55,18 +52,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<(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()
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+                __m.get_or_insert_with(i.clone(), || {
+                    (
+                        Rc::new(RefCell::new(i)),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )
+                })
+                .borrow()
+                .1
+                .as_pointer()
             })
             .write(__rhs);
         i.prefix_inc();
@@ -74,31 +70,30 @@ 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<(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()
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+                __m.get_or_insert_with(i.clone(), || {
+                    (
+                        Rc::new(RefCell::new(i)),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )
+                })
+                .borrow()
+                .1
+                .as_pointer()
             })
             .write(__rhs);
         i.prefix_inc();
     }
     assert!(
-        ((*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow()) != 0)
+        ((*(*(*it.borrow()).iter_deref().upgrade().deref()).1.borrow()) != 0)
             && (!(Ptr::<i8>::from_string_literal(
                 b"in refcount, iterator points to index 0 instead of sentinel"
             ))
             .is_null())
     );
     assert!(
-        ((*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow()) == sentinel)
+        ((*(*(*it.borrow()).iter_deref().upgrade().deref()).1.borrow()) == sentinel)
             && (!(Ptr::<i8>::from_string_literal(
                 b"iterator does not have correct value after insert"
             ))
@@ -111,23 +106,21 @@ fn main_0() -> i32 {
             ))
             .is_null())
     );
-    (*(*it.borrow())
-        .deref()
-        .with(|__p| __p.1.clone())
+    (*(*(*it.borrow()).iter_deref().upgrade().deref())
+        .1
         .borrow_mut()) = 57005;
     assert!(
-        (((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()
+        (((m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+                __m.get_or_insert_with(sentinel.clone(), || {
+                    (
+                        Rc::new(RefCell::new(sentinel)),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )
+                })
+                .borrow()
+                .1
+                .as_pointer()
             })
             .read())
             == 57005)
@@ -135,9 +128,10 @@ 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 __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();
+    'loop_: for __begin1 in Map::range(m.as_pointer()) {
+        let __begin1: Value<BidirectionalIterator<(Value<i32>, Value<i32>)>> =
+            Rc::new(RefCell::new(__begin1));
+        let pair: Ptr<(Value<i32>, Value<i32>)> = (*__begin1.borrow()).iter_deref();
         assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { prev }));
         prev = (*(*pair.upgrade().deref()).0.borrow());
     }
diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs
index 4102dfea0..101862155 100644
--- a/tests/unit/out/refcount/map.rs
+++ b/tests/unit/out/refcount/map.rs
@@ -17,449 +17,508 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    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()
+    let m: Value<Map<i16, (Value<i16>, Value<u32>)>> = Rc::new(RefCell::new(Map::new()));
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(0_i16.clone(), || {
+                (
+                    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<(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()
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(1_i16.clone(), || {
+                (
+                    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<(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)),
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(2_i16.clone(), || {
+                (
+                    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<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(0_i16.clone(), || {
+                    (
+                        Rc::new(RefCell::new(0_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<(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<(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()
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(1_i16.clone(), || {
+                    (
+                        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<(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()
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(2_i16.clone(), || {
+                    (
+                        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<(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)),
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(1_i16.clone(), || {
+                (
+                    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<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(0_i16.clone(), || {
+                    (
+                        Rc::new(RefCell::new(0_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<(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<(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()
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(1_i16.clone(), || {
+                    (
+                        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<(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()
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(2_i16.clone(), || {
+                    (
+                        Rc::new(RefCell::new(2_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )
+                })
+                .borrow()
+                .1
+                .as_pointer()
             })
             .read())
             == 3_u32)
     );
     ({
         foo_0(
-            ((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<(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((
+            ((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                    __m.get_or_insert_with(0_i16.clone(), || {
+                        (
                             Rc::new(RefCell::new(0_i16)),
                             Rc::new(RefCell::new(<u32>::default())),
-                        )))
+                        )
                     })
                     .borrow()
                     .1
                     .as_pointer()
+                })
+                .read()),
+        )
+    });
+    assert!(
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(0_i16.clone(), || {
+                    (
+                        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<(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<(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((
+            (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>).with_mut(
+                |__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                    __m.get_or_insert_with(2_i16.clone(), || {
+                        (
                             Rc::new(RefCell::new(2_i16)),
                             Rc::new(RefCell::new(<u32>::default())),
-                        )))
+                        )
                     })
                     .borrow()
                     .1
                     .as_pointer()
+                },
+            ),
+        )
+    });
+    assert!(
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(2_i16.clone(), || {
+                    (
+                        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<(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)),
+    let __rhs = ((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(0_i16.clone(), || {
+                (
+                    Rc::new(RefCell::new(0_i16)),
+                    Rc::new(RefCell::new(<u32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .read())
+    .wrapping_add(
+        ((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(2_i16.clone(), || {
+                    (
+                        Rc::new(RefCell::new(2_i16)),
                         Rc::new(RefCell::new(<u32>::default())),
-                    )))
+                    )
                 })
                 .borrow()
                 .1
                 .as_pointer()
-        })
-        .read())
-    .wrapping_add(
-        ((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<(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((
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(0_i16.clone(), || {
+                (
+                    Rc::new(RefCell::new(0_i16)),
+                    Rc::new(RefCell::new(<u32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .write(__rhs);
+    assert!(
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(0_i16.clone(), || {
+                    (
                         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<(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<(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<(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<(Value<i16>, Value<u32>)>>>),
-            &10_i16,
-        )));
+    let end: Value<BidirectionalIterator<(Value<i16>, Value<u32>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.end()),
+    ));
+    let it: Value<BidirectionalIterator<(Value<i16>, Value<u32>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&1_i16)),
+    ));
+    let const_it: Value<BidirectionalIterator<(Value<i16>, Value<u32>)>> = Rc::new(RefCell::new(
+        <BidirectionalIterator<(Value<i16>, Value<u32>)>>::from(
+            (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&10_i16)),
+        ),
+    ));
     let mut x1: u32 = if (*it.borrow()) == (*end.borrow()) {
         0_u32
     } else {
-        (*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow())
+        (*(*(*it.borrow()).iter_deref().upgrade().deref()).1.borrow())
     };
     assert!((x1 == 4_u32));
-    let mut x2: u32 = if (*const_it.borrow()) == (*end.borrow()) {
+    let mut x2: u32 = if (*const_it.borrow())
+        == <BidirectionalIterator<(Value<i16>, Value<u32>)>>::from((*end.borrow()).clone())
+    {
         0_u32
     } else {
-        (*(*const_it.borrow())
-            .deref()
-            .with(|__p| __p.1.clone())
+        (*(*(*const_it.borrow()).iter_deref().upgrade().deref())
+            .1
             .borrow())
     };
     assert!((x2 == 0_u32));
     let mut x3: u32 = if (*it.borrow())
-        == RefcountMapIter::end(
-            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
-        ) {
+        == (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.end())
+    {
         0_u32
     } else {
-        (*(*it.borrow()).deref().with(|__p| __p.1.clone()).borrow())
+        (*(*(*it.borrow()).iter_deref().upgrade().deref()).1.borrow())
     };
     assert!((x3 == 4_u32));
     let mut x4: u32 = if (*const_it.borrow())
-        == RefcountMapIter::end(
-            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
+        == <BidirectionalIterator<(Value<i16>, Value<u32>)>>::from(
+            (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.end()),
         ) {
         0_u32
     } else {
-        (*(*const_it.borrow())
-            .deref()
-            .with(|__p| __p.1.clone())
+        (*(*(*const_it.borrow()).iter_deref().upgrade().deref())
+            .1
             .borrow())
     };
     assert!((x4 == 0_u32));
-    (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((
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(4_i16.clone(), || {
+                (
+                    Rc::new(RefCell::new(4_i16)),
+                    Rc::new(RefCell::new(<u32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .write(5_u32);
+    let it4: Value<BidirectionalIterator<(Value<i16>, Value<u32>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&4_i16)),
+    ));
+    let mut p: Ptr<u32> = ((*(*it4.borrow()).iter_deref().upgrade().deref())
+        .1
+        .as_pointer());
+    let mut x5: u32 = (p.read());
+    assert!(
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(4_i16.clone(), || {
+                    (
                         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<(Value<i16>, Value<u32>)>>>),
-        &4_i16,
-    )));
-    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<(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()).deref().with(|__p| __p.1.clone()).borrow()) == 5_u32));
+    assert!(((*(*(*it4.borrow()).iter_deref().upgrade().deref()).1.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<(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()
+        (((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+                __m.get_or_insert_with(4_i16.clone(), || {
+                    (
+                        Rc::new(RefCell::new(4_i16)),
+                        Rc::new(RefCell::new(<u32>::default())),
+                    )
+                })
+                .borrow()
+                .1
+                .as_pointer()
             })
             .read())
             == 6_u32)
     );
-    assert!(((*(*it4.borrow()).deref().with(|__p| __p.1.clone()).borrow()) == 6_u32));
+    assert!(((*(*(*it4.borrow()).iter_deref().upgrade().deref()).1.borrow()) == 6_u32));
     assert!(((p.read()) == 6_u32));
     assert!((x5 == 5_u32));
-    let const_it4: Value<RefcountMapIter<i16, u32>> =
-        Rc::new(RefCell::new(RefcountMapIter::find_key(
-            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
-            &4_i16,
-        )));
+    let const_it4: Value<BidirectionalIterator<(Value<i16>, Value<u32>)>> = Rc::new(RefCell::new(
+        <BidirectionalIterator<(Value<i16>, Value<u32>)>>::from(
+            (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&4_i16)),
+        ),
+    ));
     assert!(
-        ((*(*(*const_it4.borrow()).deref().upgrade().deref())
+        ((*(*(*const_it4.borrow()).iter_deref().upgrade().deref())
             .1
             .borrow())
             == 6_u32)
     );
-    let r: Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>> = m.as_pointer();
+    let r: Ptr<Map<i16, (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<(Value<i16>, Value<u32>)>>>),
-            &4_i16
-        ) != RefcountMapIter::end(
-            (m.as_pointer() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>)
-        )
+        (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&4_i16))
+            != (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.end())
     );
-    RefcountMapIter::erase(
-        ((r).clone() as Ptr<BTreeMap<i16, Value<(Value<i16>, Value<u32>)>>>),
-        &(*it4.borrow()).clone(),
+    ((r).clone() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>).with_mut(
+        |__m: &mut Map<i16, (Value<i16>, Value<u32>)>| __m.erase(&(*it4.borrow()).clone()),
     );
     assert!(((*r.upgrade().deref()).len() == 3_usize));
     assert!(
-        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>)>>>)
-        )
+        (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&4_i16))
+            == (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.end())
+    );
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(7_i16.clone(), || {
+                (
+                    Rc::new(RefCell::new(7_i16)),
+                    Rc::new(RefCell::new(<u32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .write(7_u32);
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(8_i16.clone(), || {
+                (
+                    Rc::new(RefCell::new(8_i16)),
+                    Rc::new(RefCell::new(<u32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .write(8_u32);
+    (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+        .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| {
+            __m.get_or_insert_with(9_i16.clone(), || {
+                (
+                    Rc::new(RefCell::new(9_i16)),
+                    Rc::new(RefCell::new(<u32>::default())),
+                )
+            })
+            .borrow()
+            .1
+            .as_pointer()
+        })
+        .write(9_u32);
+    assert!(((*r.upgrade().deref()).len() == 6_usize));
+    assert!(
+        ((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| __m.erase_key(&10_i16))
+            == 0_usize)
+    );
+    let mut key9: i32 = 9;
+    assert!(
+        ((m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with_mut(|__m: &mut Map<i16, (Value<i16>, Value<u32>)>| __m.erase_key(&(key9 as i16)))
+            == 1_usize)
+    );
+    assert!(((*r.upgrade().deref()).len() == 5_usize));
+    let cit: Value<BidirectionalIterator<(Value<i16>, Value<u32>)>> = Rc::new(RefCell::new(
+        <BidirectionalIterator<(Value<i16>, Value<u32>)>>::from(
+            (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&7_i16)),
+        ),
+    ));
+    let next: Value<BidirectionalIterator<(Value<i16>, Value<u32>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>).with_mut(
+            |__m: &mut Map<i16, (Value<i16>, Value<u32>)>| __m.erase(&(*cit.borrow()).clone()),
+        ),
+    ));
+    assert!(
+        (*next.borrow())
+            == (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&8_i16))
+    );
+    (*next.borrow_mut()) = (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>).with_mut(
+        |__m: &mut Map<i16, (Value<i16>, Value<u32>)>| __m.erase(&(*next.borrow()).clone()),
+    );
+    assert!(
+        (*next.borrow())
+            == (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.end())
+    );
+    assert!(((*r.upgrade().deref()).len() == 3_usize));
+    assert!(
+        (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+            .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.find(&8_i16))
+            == (m.as_pointer() as Ptr<Map<i16, (Value<i16>, Value<u32>)>>)
+                .with(|__m: &Map<i16, (Value<i16>, Value<u32>)>| __m.end())
     );
     let other_map: Value<
-        BTreeMap<(Value<i32>, Value<i64>), Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>>,
-    > = Rc::new(RefCell::new(BTreeMap::new()));
+        Map<(Value<i32>, Value<i64>), (Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+    > = Rc::new(RefCell::new(Map::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"))),
@@ -467,79 +526,61 @@ fn main_0() -> i32 {
     )));
     let mut value: f64 = 2_f64;
     (other_map.as_pointer()
-        as Ptr<
-            BTreeMap<
-                (Value<i32>, Value<i64>),
-                Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
-            >,
-        >)
+        as Ptr<Map<(Value<i32>, Value<i64>), (Value<(Value<i32>, Value<i64>)>, Value<f64>)>>)
         .with_mut(
-            |__v: &mut BTreeMap<
+            |__m: &mut Map<
                 (Value<i32>, Value<i64>),
-                Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+                (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()
+                __m.get_or_insert_with((*key0.borrow()).clone(), || {
+                    (
+                        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<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
-            >,
-        >)
+        as Ptr<Map<(Value<i32>, Value<i64>), (Value<(Value<i32>, Value<i64>)>, Value<f64>)>>)
         .with_mut(
-            |__v: &mut BTreeMap<
+            |__m: &mut Map<
                 (Value<i32>, Value<i64>),
-                Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+                (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()
+                __m.get_or_insert_with((*key0.borrow()).clone(), || {
+                    (
+                        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<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
-                >,
-            >)
+            as Ptr<Map<(Value<i32>, Value<i64>), (Value<(Value<i32>, Value<i64>)>, Value<f64>)>>)
             .with_mut(
-                |__v: &mut BTreeMap<
+                |__m: &mut Map<
                     (Value<i32>, Value<i64>),
-                    Value<(Value<(Value<i32>, Value<i64>)>, Value<f64>)>,
+                    (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()
+                    __m.get_or_insert_with((*key0.borrow()).clone(), || {
+                        (
+                            Rc::new(RefCell::new((*key0.borrow()).clone())),
+                            Rc::new(RefCell::new(<f64>::default())),
+                        )
+                    })
+                    .borrow()
+                    .1
+                    .as_pointer()
                 }
             )
             .read())
@@ -579,8 +620,7 @@ fn main_0() -> i32 {
             .read())
             == 4_u32)
     );
-    let m2: Value<BTreeMap<i32, Value<(Value<i32>, Value<bool>)>>> =
-        Rc::new(RefCell::new(BTreeMap::new()));
+    let m2: Value<Map<i32, (Value<i32>, Value<bool>)>> = Rc::new(RefCell::new(Map::new()));
     assert!(((*m2.borrow()).len() == 0_usize));
     let mut indexes: Vec<i32> = Vec::new();
     let mut i: u32 = 60_u32;
@@ -610,29 +650,27 @@ 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<(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()
-                },
-            )
+        (m2.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<bool>)>>)
+            .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<bool>)>| {
+                __m.get_or_insert_with(indexes[(i as usize)].clone(), || {
+                    (
+                        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 __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();
+    'loop_: for __begin1 in Map::range(m2.as_pointer()) {
+        let __begin1: Value<BidirectionalIterator<(Value<i32>, Value<bool>)>> =
+            Rc::new(RefCell::new(__begin1));
+        let pair: Ptr<(Value<i32>, Value<bool>)> = (*__begin1.borrow()).iter_deref();
         assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { last }));
         assert!(
             ({ ((*(*pair.upgrade().deref()).1.borrow()) as i32) } == {
diff --git a/tests/unit/out/refcount/max.rs b/tests/unit/out/refcount/max.rs
index d7b927b97..871c6e8c8 100644
--- a/tests/unit/out/refcount/max.rs
+++ b/tests/unit/out/refcount/max.rs
@@ -54,21 +54,23 @@ fn main_0() -> i32 {
     assert!((((((r1 + r2) + r3) + r4) + r5) == 56));
     let values: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 7, 7, 3])));
     let mut max: Ptr<i32> = {
-        let count = (values.as_pointer() as Ptr<i32>)
-            .offset((4) as isize)
-            .get_offset()
-            - (values.as_pointer() as Ptr<i32>).get_offset();
-        let max_index = PtrValueIter::new(&(values.as_pointer() as Ptr<i32>), count)
-            .enumerate()
-            .max_by(|(idx_a, val_a), (idx_b, val_b)| {
-                val_a
-                    .partial_cmp(val_b)
-                    .unwrap_or(std::cmp::Ordering::Equal)
-                    .then_with(|| idx_b.cmp(idx_a))
-            })
-            .map(|(idx, _)| idx)
-            .unwrap_or(0);
-        (values.as_pointer() as Ptr<i32>) + max_index
+        let mut __best = (values.as_pointer() as Ptr<i32>).clone();
+        if (values.as_pointer() as Ptr<i32>)
+            != (values.as_pointer() as Ptr<i32>).offset((4) as isize)
+        {
+            let mut __it = (values.as_pointer() as Ptr<i32>);
+            __it.iter_inc();
+            while __it != (values.as_pointer() as Ptr<i32>).offset((4) as isize) {
+                if __best
+                    .iter_deref()
+                    .with(|__b| __it.iter_deref().with(|__v| __b < __v))
+                {
+                    __best = __it.clone();
+                }
+                __it.iter_inc();
+            }
+        }
+        __best
     };
     assert!(({ (max).clone() } == { (values.as_pointer() as Ptr::<i32>).offset((1) as isize) }));
     return 0;
diff --git a/tests/unit/out/refcount/operator_comparison_nonbool.rs b/tests/unit/out/refcount/operator_comparison_nonbool.rs
index cc87e5746..bec98b4be 100644
--- a/tests/unit/out/refcount/operator_comparison_nonbool.rs
+++ b/tests/unit/out/refcount/operator_comparison_nonbool.rs
@@ -267,11 +267,26 @@ fn main_0() -> i32 {
         }) == 7)
     );
     let xs: Value<Box<[X]>> = Rc::new(RefCell::new(Box::new([X { v: 3 }, X { v: 1 }, X { v: 2 }])));
-    (xs.as_pointer() as Ptr<X>).sort(
-        (xs.as_pointer() as Ptr<X>)
+    {
+        let __n = (xs.as_pointer() as Ptr<X>)
             .offset((3) as isize)
-            .get_offset(),
-    );
+            .iter_distance(&(xs.as_pointer() as Ptr<X>));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (xs.as_pointer() as Ptr<X>).iter_at(__x).with(|__a| {
+                (xs.as_pointer() as Ptr<X>)
+                    .iter_at(__y)
+                    .with(|__b| __a.cmp(__b))
+            })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| (xs.as_pointer() as Ptr<X>).iter_at(__i).read())
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            (xs.as_pointer() as Ptr<X>).iter_at(__i).write(__v);
+        }
+    };
     assert!(
         (({ (*xs.borrow())[(0) as usize].v } == 1) && ({ (*xs.borrow())[(1) as usize].v } == 2))
             && ({ (*xs.borrow())[(2) as usize].v } == 3)
@@ -289,11 +304,26 @@ fn main_0() -> i32 {
         Mixed { v: 4 },
         Mixed { v: 5 },
     ])));
-    (ms.as_pointer() as Ptr<Mixed>).sort(
-        (ms.as_pointer() as Ptr<Mixed>)
+    {
+        let __n = (ms.as_pointer() as Ptr<Mixed>)
             .offset((3) as isize)
-            .get_offset(),
-    );
+            .iter_distance(&(ms.as_pointer() as Ptr<Mixed>));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (ms.as_pointer() as Ptr<Mixed>).iter_at(__x).with(|__a| {
+                (ms.as_pointer() as Ptr<Mixed>)
+                    .iter_at(__y)
+                    .with(|__b| __a.cmp(__b))
+            })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| (ms.as_pointer() as Ptr<Mixed>).iter_at(__i).read())
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            (ms.as_pointer() as Ptr<Mixed>).iter_at(__i).write(__v);
+        }
+    };
     assert!(
         (({ (*ms.borrow())[(0) as usize].v } == 4) && ({ (*ms.borrow())[(1) as usize].v } == 5))
             && ({ (*ms.borrow())[(2) as usize].v } == 6)
@@ -342,11 +372,26 @@ fn main_0() -> i32 {
         Boolish { v: 1 },
         Boolish { v: 2 },
     ])));
-    (bs.as_pointer() as Ptr<Boolish>).sort(
-        (bs.as_pointer() as Ptr<Boolish>)
+    {
+        let __n = (bs.as_pointer() as Ptr<Boolish>)
             .offset((3) as isize)
-            .get_offset(),
-    );
+            .iter_distance(&(bs.as_pointer() as Ptr<Boolish>));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (bs.as_pointer() as Ptr<Boolish>).iter_at(__x).with(|__a| {
+                (bs.as_pointer() as Ptr<Boolish>)
+                    .iter_at(__y)
+                    .with(|__b| __a.cmp(__b))
+            })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| (bs.as_pointer() as Ptr<Boolish>).iter_at(__i).read())
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            (bs.as_pointer() as Ptr<Boolish>).iter_at(__i).write(__v);
+        }
+    };
     assert!(
         (({ (*bs.borrow())[(0) as usize].v } == 1) && ({ (*bs.borrow())[(1) as usize].v } == 2))
             && ({ (*bs.borrow())[(2) as usize].v } == 3)
@@ -364,18 +409,13 @@ fn main_0() -> i32 {
         Rc::new(RefCell::new(Box::new([RefInt { v: 1 }, RefInt { v: 2 }])));
     assert!(
         ({
-            let count = ((ris.as_pointer() as Ptr<RefInt>)
-                .offset((2) as isize)
-                .get_offset()
-                - (ris.as_pointer() as Ptr<RefInt>).get_offset()) as usize;
-            (ris.as_pointer() as Ptr<RefInt>).offset(
-                (ris.as_pointer() as Ptr<RefInt>)
-                    .clone()
-                    .into_iter()
-                    .take(count)
-                    .position(|value_0| value_0.read() == (*ri2.borrow()))
-                    .unwrap_or(count) as isize,
-            )
+            let mut __it = (ris.as_pointer() as Ptr<RefInt>);
+            while __it != (ris.as_pointer() as Ptr<RefInt>).offset((2) as isize)
+                && __it.iter_deref().with(|__v| *__v != (*ri2.borrow()))
+            {
+                __it.iter_inc();
+            }
+            __it
         } == (ris.as_pointer() as Ptr<RefInt>))
     );
     return 0;
diff --git a/tests/unit/out/refcount/operator_traits.rs b/tests/unit/out/refcount/operator_traits.rs
index f6a328f26..133a20072 100644
--- a/tests/unit/out/refcount/operator_traits.rs
+++ b/tests/unit/out/refcount/operator_traits.rs
@@ -160,7 +160,33 @@ fn main_0() -> i32 {
     let mut w: Wrapped_int_ = Wrapped_int_ { v: 2 };
     assert!((w.v == 2));
     let lts: Value<Vec<Lt>> = Rc::new(RefCell::new(vec![Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }]));
-    (lts.as_pointer() as Ptr<Lt>).sort((lts.as_pointer() as Ptr<Lt>).to_end().get_offset());
+    {
+        let __n = RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>).to_end())
+            .iter_distance(&RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>)));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>))
+                .iter_at(__x)
+                .with(|__a| {
+                    RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>))
+                        .iter_at(__y)
+                        .with(|__b| __a.cmp(__b))
+                })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>))
+                    .iter_at(__i)
+                    .read()
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>))
+                .iter_at(__i)
+                .write(__v);
+        }
+    };
     assert!(
         (({ (*lts.borrow())[0_usize].v } == 1) && ({ (*lts.borrow())[1_usize].v } == 2))
             && ({ (*lts.borrow())[2_usize].v } == 3)
@@ -170,136 +196,169 @@ fn main_0() -> i32 {
     let mut nine: Eq = Eq { v: 9 };
     assert!(
         ({
-            ({
-                let count = ((eqs.as_pointer() as Ptr<Eq>).to_end().get_offset()
-                    - (eqs.as_pointer() as Ptr<Eq>).get_offset())
-                    as usize;
-                (eqs.as_pointer() as Ptr<Eq>).offset(
-                    (eqs.as_pointer() as Ptr<Eq>)
-                        .clone()
-                        .into_iter()
-                        .take(count)
-                        .position(|value_0| value_0.read() == two)
-                        .unwrap_or(count) as isize,
-                )
+            let mut __it = RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>));
+            while __it != RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>).to_end())
+                && __it.iter_deref().with(|__v| *__v != two)
+            {
+                __it.iter_inc();
             }
-            .read())
-            .v
-        } == 2)
+            __it
+        }
+        .iter_deref()
+        .with(|__s| __s.v)
+            == 2)
     );
     assert!(
         {
-            let count = ((eqs.as_pointer() as Ptr<Eq>).to_end().get_offset()
-                - (eqs.as_pointer() as Ptr<Eq>).get_offset()) as usize;
-            (eqs.as_pointer() as Ptr<Eq>).offset(
-                (eqs.as_pointer() as Ptr<Eq>)
-                    .clone()
-                    .into_iter()
-                    .take(count)
-                    .position(|value_0| value_0.read() == nine)
-                    .unwrap_or(count) as isize,
-            )
-        } == (eqs.as_pointer() as Ptr<Eq>).to_end()
+            let mut __it = RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>));
+            while __it != RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>).to_end())
+                && __it.iter_deref().with(|__v| *__v != nine)
+            {
+                __it.iter_inc();
+            }
+            __it
+        } == RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>).to_end())
     );
     let cmps: Value<Vec<Cmp>> =
         Rc::new(RefCell::new(vec![Cmp { v: 3 }, Cmp { v: 1 }, Cmp { v: 2 }]));
-    (cmps.as_pointer() as Ptr<Cmp>).sort((cmps.as_pointer() as Ptr<Cmp>).to_end().get_offset());
+    {
+        let __n = RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>).to_end())
+            .iter_distance(&RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>)));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>))
+                .iter_at(__x)
+                .with(|__a| {
+                    RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>))
+                        .iter_at(__y)
+                        .with(|__b| __a.cmp(__b))
+                })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>))
+                    .iter_at(__i)
+                    .read()
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>))
+                .iter_at(__i)
+                .write(__v);
+        }
+    };
     assert!(({ (*cmps.borrow())[0_usize].v } == 1) && ({ (*cmps.borrow())[2_usize].v } == 3));
     let mut three: Cmp = Cmp { v: 3 };
     assert!(
         ({
-            ({
-                let count = ((cmps.as_pointer() as Ptr<Cmp>).to_end().get_offset()
-                    - (cmps.as_pointer() as Ptr<Cmp>).get_offset())
-                    as usize;
-                (cmps.as_pointer() as Ptr<Cmp>).offset(
-                    (cmps.as_pointer() as Ptr<Cmp>)
-                        .clone()
-                        .into_iter()
-                        .take(count)
-                        .position(|value_0| value_0.read() == three)
-                        .unwrap_or(count) as isize,
-                )
+            let mut __it = RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>));
+            while __it != RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>).to_end())
+                && __it.iter_deref().with(|__v| *__v != three)
+            {
+                __it.iter_inc();
             }
-            .read())
-            .v
-        } == 3)
+            __it
+        }
+        .iter_deref()
+        .with(|__s| __s.v)
+            == 3)
     );
     let frees: Value<Vec<Free>> = Rc::new(RefCell::new(vec![Free { v: 2 }, Free { v: 1 }]));
-    (frees.as_pointer() as Ptr<Free>).sort((frees.as_pointer() as Ptr<Free>).to_end().get_offset());
+    {
+        let __n = RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>).to_end())
+            .iter_distance(&RandomAccessIterator::Vec(
+                (frees.as_pointer() as Ptr<Free>),
+            ));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>))
+                .iter_at(__x)
+                .with(|__a| {
+                    RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>))
+                        .iter_at(__y)
+                        .with(|__b| __a.cmp(__b))
+                })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>))
+                    .iter_at(__i)
+                    .read()
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>))
+                .iter_at(__i)
+                .write(__v);
+        }
+    };
     assert!(({ (*frees.borrow())[0_usize].v } == 1));
     let mut ftwo: Free = Free { v: 2 };
     assert!(
         ({
-            ({
-                let count = ((frees.as_pointer() as Ptr<Free>).to_end().get_offset()
-                    - (frees.as_pointer() as Ptr<Free>).get_offset())
-                    as usize;
-                (frees.as_pointer() as Ptr<Free>).offset(
-                    (frees.as_pointer() as Ptr<Free>)
-                        .clone()
-                        .into_iter()
-                        .take(count)
-                        .position(|value_0| value_0.read() == ftwo)
-                        .unwrap_or(count) as isize,
-                )
+            let mut __it = RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>));
+            while __it != RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>).to_end())
+                && __it.iter_deref().with(|__v| *__v != ftwo)
+            {
+                __it.iter_inc();
             }
-            .read())
-            .v
-        } == 2)
+            __it
+        }
+        .iter_deref()
+        .with(|__s| __s.v)
+            == 2)
     );
-    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()
+    let m: Value<Map<Lt, (Value<Lt>, Value<i32>)>> = Rc::new(RefCell::new(Map::new()));
+    (m.as_pointer() as Ptr<Map<Lt, (Value<Lt>, Value<i32>)>>)
+        .with_mut(|__m: &mut Map<Lt, (Value<Lt>, Value<i32>)>| {
+            __m.get_or_insert_with(Lt { v: 2 }.clone(), || {
+                (
+                    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<(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()
+    (m.as_pointer() as Ptr<Map<Lt, (Value<Lt>, Value<i32>)>>)
+        .with_mut(|__m: &mut Map<Lt, (Value<Lt>, Value<i32>)>| {
+            __m.get_or_insert_with(Lt { v: 1 }.clone(), || {
+                (
+                    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<(Value<Lt>, Value<i32>)>>>)
-        )
-        .deref()
-        .with(|__p| __p.1.clone())
+        ((*(*(m.as_pointer() as Ptr<Map<Lt, (Value<Lt>, Value<i32>)>>)
+            .with(|__m: &Map<Lt, (Value<Lt>, Value<i32>)>| __m.begin())
+            .iter_deref()
+            .upgrade()
+            .deref())
+        .1
         .borrow())
             == 10)
     );
     assert!(
-        (((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()
+        (((m.as_pointer() as Ptr<Map<Lt, (Value<Lt>, Value<i32>)>>)
+            .with_mut(|__m: &mut Map<Lt, (Value<Lt>, Value<i32>)>| {
+                __m.get_or_insert_with(Lt { v: 2 }.clone(), || {
+                    (
+                        Rc::new(RefCell::new(Lt { v: 2 })),
+                        Rc::new(RefCell::new(<i32>::default())),
+                    )
+                })
+                .borrow()
+                .1
+                .as_pointer()
             })
             .read())
             == 20)
diff --git a/tests/unit/out/refcount/pointer_usize_arith.rs b/tests/unit/out/refcount/pointer_usize_arith.rs
index 968ed1f3a..c4e5dde6c 100644
--- a/tests/unit/out/refcount/pointer_usize_arith.rs
+++ b/tests/unit/out/refcount/pointer_usize_arith.rs
@@ -19,8 +19,8 @@ fn main_0() -> i32 {
     assert!(((r.read()) == 13));
     let mut s: Ptr<i32> = r.offset(-((2) as isize));
     assert!(((s.read()) == 11));
-    let mut diff: i64 = ((r).clone() - (p).clone()) as i64;
-    assert!((diff == 3_i64));
+    let mut diff: isize = (((r).clone() - (p).clone()) as i64 as isize);
+    assert!((diff == 3_isize));
     let mut idx: usize = ((((r).clone() - (p).clone()) as i64) as usize);
     assert!((idx == 3_usize));
     let mut q2: Ptr<i32> = (p).clone();
@@ -62,13 +62,13 @@ fn main_0() -> i32 {
     let mut bp: Ptr<u8> = (bytes.as_pointer() as Ptr<u8>);
     let mut bq: Ptr<u8> = bp.offset((4) as isize);
     assert!((((bq.read()) as i32) == 4));
-    let mut bdiff: i64 = ((bq).clone() - (bp).clone()) as i64;
-    assert!((bdiff == 4_i64));
+    let mut bdiff: isize = (((bq).clone() - (bp).clone()) as i64 as isize);
+    assert!((bdiff == 4_isize));
     let mut cp: Ptr<i32> = (arr.as_pointer() as Ptr<i32>);
     let mut cq: Ptr<i32> = cp.offset((2) as isize);
     assert!(((cq.read()) == 12));
-    let mut cdiff: i64 = ((cq).clone() - (cp).clone()) as i64;
-    assert!((cdiff == 2_i64));
+    let mut cdiff: isize = (((cq).clone() - (cp).clone()) as i64 as isize);
+    assert!((cdiff == 2_isize));
     let mut n: usize = 3_usize;
     let mut q5: Ptr<i32> = (arr.as_pointer() as Ptr<i32>).offset((n) as isize);
     assert!(((q5.read()) == 13));
diff --git a/tests/unit/out/refcount/redundant_copy_in_conversion.rs b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
index b1420ce0e..4fcafd8d3 100644
--- a/tests/unit/out/refcount/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
@@ -6,11 +6,15 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-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()).deref().with(|__p| __p.1.clone()).borrow())
+pub fn sink_0(it: BidirectionalIterator<(Value<i32>, Value<i32>)>) -> i32 {
+    let it: Value<BidirectionalIterator<(Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(it));
+    let cit: Value<BidirectionalIterator<(Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(
+        <BidirectionalIterator<(Value<i32>, Value<i32>)>>::from((*it.borrow()).clone()),
+    ));
+    return if (*cit.borrow())
+        == <BidirectionalIterator<(Value<i32>, Value<i32>)>>::from((*it.borrow()).clone())
+    {
+        (*(*(*it.borrow()).iter_deref().upgrade().deref()).1.borrow())
     } else {
         0
     };
@@ -20,31 +24,34 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    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()
+    let m: Value<Map<i32, (Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(Map::new()));
+    (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+        .with_mut(|__m: &mut Map<i32, (Value<i32>, Value<i32>)>| {
+            __m.get_or_insert_with(0.clone(), || {
+                (
+                    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<(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<(Value<i32>, Value<i32>)>>>),
-        &0,
-    )));
-    let const_it: Value<RefcountMapIter<i32, i32>> = Rc::new(RefCell::new((*it0.borrow()).clone()));
-    let mut r: i32 = if (*const_it.borrow()) == (*end.borrow()) {
+    let end: Value<BidirectionalIterator<(Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.end()),
+    ));
+    let it0: Value<BidirectionalIterator<(Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.find(&0)),
+    ));
+    let const_it: Value<BidirectionalIterator<(Value<i32>, Value<i32>)>> = Rc::new(RefCell::new(
+        <BidirectionalIterator<(Value<i32>, Value<i32>)>>::from((*it0.borrow()).clone()),
+    ));
+    let mut r: i32 = if (*const_it.borrow())
+        == <BidirectionalIterator<(Value<i32>, Value<i32>)>>::from((*end.borrow()).clone())
+    {
         0
     } else {
         1
diff --git a/tests/unit/out/refcount/sort.rs b/tests/unit/out/refcount/sort.rs
index 331781680..a0ec040ff 100644
--- a/tests/unit/out/refcount/sort.rs
+++ b/tests/unit/out/refcount/sort.rs
@@ -52,7 +52,33 @@ fn main_0() -> i32 {
         let __a1 = 6;
         (*v.borrow_mut()).push(__a1)
     };
-    (v.as_pointer() as Ptr<i32>).sort((v.as_pointer() as Ptr<i32>).to_end().get_offset());
+    {
+        let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end())
+            .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+                .iter_at(__x)
+                .with(|__a| {
+                    RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+                        .iter_at(__y)
+                        .with(|__b| __a.cmp(__b))
+                })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+                    .iter_at(__i)
+                    .read()
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+                .iter_at(__i)
+                .write(__v);
+        }
+    };
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < ((*v.borrow()).len()).wrapping_sub(1_usize)) {
         assert!(
diff --git a/tests/unit/out/refcount/split_binop_aliased_borrows.rs b/tests/unit/out/refcount/split_binop_aliased_borrows.rs
index f6b9b1054..1691fb8aa 100644
--- a/tests/unit/out/refcount/split_binop_aliased_borrows.rs
+++ b/tests/unit/out/refcount/split_binop_aliased_borrows.rs
@@ -12,10 +12,12 @@ pub fn main() {
 }
 fn main_0() -> i32 {
     let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 2]));
-    let mut p: Ptr<i32> = (v.as_pointer() as Ptr<i32>);
+    let p: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(RandomAccessIterator::Vec(
+        (v.as_pointer() as Ptr<i32>),
+    )));
     let r: Ptr<i32> = (v.as_pointer() as Ptr<i32>).offset(1_usize);
     let __rhs = (r.read());
-    p.write(__rhs);
+    (*p.borrow()).iter_deref().write(__rhs);
     assert!(({ (*v.borrow())[0_usize] } == 2));
     return 0;
 }
diff --git a/tests/unit/out/refcount/stdcopy.rs b/tests/unit/out/refcount/stdcopy.rs
index 04b6d2eb5..c6d7928d5 100644
--- a/tests/unit/out/refcount/stdcopy.rs
+++ b/tests/unit/out/refcount/stdcopy.rs
@@ -15,16 +15,14 @@ fn main_0() -> i32 {
     let output: Value<Box<[i32]>> =
         Rc::new(RefCell::new((0..3).map(|_| 0_i32).collect::<Box<[i32]>>()));
     {
-        let count = (input.as_pointer() as Ptr<i32>)
-            .offset((3) as isize)
-            .get_offset()
-            - (input.as_pointer() as Ptr<i32>).get_offset();
-        let mut outptr = (output.as_pointer() as Ptr<i32>);
-        for value in PtrValueIter::new(&(input.as_pointer() as Ptr<i32>), count) {
-            outptr.write(value.into());
-            outptr += 1;
+        let mut __first = (input.as_pointer() as Ptr<i32>);
+        let mut __out = (output.as_pointer() as Ptr<i32>);
+        while __first != (input.as_pointer() as Ptr<i32>).offset((3) as isize) {
+            __out.iter_deref().write(__first.iter_deref().read().into());
+            __first.iter_inc();
+            __out.iter_inc();
         }
-        outptr
+        __out
     };
     return 0;
 }
diff --git a/tests/unit/out/refcount/sys_stat.rs b/tests/unit/out/refcount/sys_stat.rs
index 25445bb2c..4f8e92c3c 100644
--- a/tests/unit/out/refcount/sys_stat.rs
+++ b/tests/unit/out/refcount/sys_stat.rs
@@ -45,7 +45,9 @@ pub fn test_stat_0() {
             != 0)
     );
     assert!(((({ (*st.borrow()).st_size } == 5_i64) as i32) != 0));
-    assert!(((((field_ptr!(st.as_pointer(), st_mtime).read()) > 0_i64) as i32) != 0));
+    assert!(
+        ((((field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).read()) > 0_i64) as i32) != 0)
+    );
     match nix::unistd::unlink(path.to_rust_string().as_str()) {
         Ok(()) => 0,
         Err(__e) => {
@@ -87,7 +89,9 @@ pub fn test_fstat_1() {
             != 0)
     );
     assert!(((({ (*st.borrow()).st_size } == 11_i64) as i32) != 0));
-    assert!(((((field_ptr!(st.as_pointer(), st_mtime).read()) > 0_i64) as i32) != 0));
+    assert!(
+        ((((field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).read()) > 0_i64) as i32) != 0)
+    );
     assert!(
         ((({
             let __r = fp.with(|__f| __f.close());
@@ -107,28 +111,36 @@ pub fn test_fstat_1() {
 pub fn test_st_mtime_access_2() {
     let st: Value<libcc2rs::Stat> = Rc::new(RefCell::new(Default::default()));
     let mut sp: Ptr<libcc2rs::Stat> = (st.as_pointer());
-    field_ptr!(st.as_pointer(), st_mtime).write(5_i64);
-    assert!(((((field_ptr!(st.as_pointer(), st_mtime).read()) == 5_i64) as i32) != 0));
-    field_ptr!(sp, st_mtime).write(6_i64);
-    assert!(((((field_ptr!(sp, st_mtime).read()) == 6_i64) as i32) != 0));
+    field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).write(5_i64);
+    assert!(
+        ((((field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).read()) == 5_i64) as i32) != 0)
+    );
+    field_ptr!(((sp).clone() as Ptr<Stat>), st_mtime).write(6_i64);
+    assert!(((((field_ptr!(((sp).clone() as Ptr<Stat>), st_mtime).read()) == 6_i64) as i32) != 0));
     {
-        field_ptr!(st.as_pointer(), st_mtime).with_mut(|__v| *__v = *__v + 2_i64)
+        field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).with_mut(|__v| *__v = *__v + 2_i64)
     };
-    assert!(((((field_ptr!(st.as_pointer(), st_mtime).read()) == 8_i64) as i32) != 0));
+    assert!(
+        ((((field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).read()) == 8_i64) as i32) != 0)
+    );
     {
-        field_ptr!(sp, st_mtime).with_mut(|__v| *__v = *__v - 1_i64)
+        field_ptr!(((sp).clone() as Ptr<Stat>), st_mtime).with_mut(|__v| *__v = *__v - 1_i64)
     };
-    assert!(((((field_ptr!(sp, st_mtime).read()) == 7_i64) as i32) != 0));
-    field_ptr!(st.as_pointer(), st_mtime).with_mut(|__v| __v.postfix_inc());
-    field_ptr!(sp, st_mtime).with_mut(|__v| __v.prefix_inc());
-    assert!(((((field_ptr!(st.as_pointer(), st_mtime).read()) == 9_i64) as i32) != 0));
-    let mut mtime: Ptr<i64> = (field_ptr!(st.as_pointer(), st_mtime));
+    assert!(((((field_ptr!(((sp).clone() as Ptr<Stat>), st_mtime).read()) == 7_i64) as i32) != 0));
+    field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).with_mut(|__v| __v.postfix_inc());
+    field_ptr!(((sp).clone() as Ptr<Stat>), st_mtime).with_mut(|__v| __v.prefix_inc());
+    assert!(
+        ((((field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).read()) == 9_i64) as i32) != 0)
+    );
+    let mut mtime: Ptr<i64> = (field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime));
     mtime.write(10_i64);
-    assert!(((((field_ptr!(st.as_pointer(), st_mtime).read()) == 10_i64) as i32) != 0));
-    let mut mtime_via_ptr: Ptr<i64> = (field_ptr!(sp, st_mtime));
+    assert!(
+        ((((field_ptr!((st.as_pointer() as Ptr<Stat>), st_mtime).read()) == 10_i64) as i32) != 0)
+    );
+    let mut mtime_via_ptr: Ptr<i64> = (field_ptr!(((sp).clone() as Ptr<Stat>), st_mtime));
     mtime_via_ptr.write(11_i64);
     assert!(((((mtime.read()) == 11_i64) as i32) != 0));
-    let mut copy: i64 = (field_ptr!(sp, st_mtime).read());
+    let mut copy: i64 = (field_ptr!(((sp).clone() as Ptr<Stat>), st_mtime).read());
     assert!((((copy == 11_i64) as i32) != 0));
 }
 pub fn main() {
diff --git a/tests/unit/out/refcount/unboxed_conditional_iterator.rs b/tests/unit/out/refcount/unboxed_conditional_iterator.rs
index bd3a3b0d6..21fae41de 100644
--- a/tests/unit/out/refcount/unboxed_conditional_iterator.rs
+++ b/tests/unit/out/refcount/unboxed_conditional_iterator.rs
@@ -47,37 +47,44 @@ pub fn lehmer_2(mut sigma: Ptr<u32>, mut len: u32, mut code: Ptr<u32>) {
     }
     let mut i: u32 = 0_u32;
     'loop_: while (i < len) {
-        let mut it: Ptr<u32> = {
-            let count = ((items.as_pointer() as Ptr<u32>).to_end().get_offset()
-                - (items.as_pointer() as Ptr<u32>).get_offset()) as usize;
-            (items.as_pointer() as Ptr<u32>).offset(
-                (items.as_pointer() as Ptr<u32>)
-                    .clone()
-                    .into_iter()
-                    .take(count)
-                    .position(|value_0| value_0.read() == (elem!(sigma, i).read()))
-                    .unwrap_or(count) as isize,
-            )
-        };
-        assert!(it != (items.as_pointer() as Ptr<u32>).to_end());
-        let __rhs = (((it.get_offset() as isize)
-            - ((items.as_pointer() as Ptr<u32>).get_offset() as isize))
+        let it: Value<RandomAccessIterator<u32>> = Rc::new(RefCell::new({
+            let mut __it = RandomAccessIterator::Vec((items.as_pointer() as Ptr<u32>));
+            while __it != RandomAccessIterator::Vec((items.as_pointer() as Ptr<u32>).to_end())
+                && __it
+                    .iter_deref()
+                    .with(|__v| *__v != (elem!(sigma, i).read()))
+            {
+                __it.iter_inc();
+            }
+            __it
+        }));
+        assert!(
+            (*it.borrow()) != RandomAccessIterator::Vec((items.as_pointer() as Ptr<u32>).to_end())
+        );
+        let __rhs = ((*it.borrow())
+            .iter_distance(&RandomAccessIterator::Vec((items.as_pointer() as Ptr<u32>)))
             as u32);
         elem!(code, i).write(__rhs);
         {
-            let idx = it.get_offset();
+            let idx = <RandomAccessIterator<u32>>::from((*it.borrow()).clone())
+                .vec_ptr()
+                .get_offset();
             (items.as_pointer() as Ptr<Vec<u32>>).with_mut(|__v: &mut Vec<u32>| __v.remove(idx));
-            (items.as_pointer() as Ptr<Vec<u32>>).decay()
+            RandomAccessIterator::Vec((items.as_pointer() as Ptr<Vec<u32>>).decay())
         };
         i.prefix_inc();
     }
 }
 pub fn sum_3(v: Ptr<Vec<i32>>) -> i32 {
     let mut s: i32 = 0;
-    let mut it: Ptr<i32> = (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>);
-    'loop_: while it != (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>).to_end() {
-        s += (it.read());
-        it.prefix_inc();
+    let it: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(RandomAccessIterator::Vec(
+        (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>),
+    )));
+    'loop_: while (*it.borrow())
+        != RandomAccessIterator::Vec((Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>).to_end())
+    {
+        s += ((*it.borrow()).iter_deref().read());
+        (*it.borrow_mut()).iter_inc();
     }
     return s;
 }
diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs
index c4e0abeb9..9cb8df477 100644
--- a/tests/unit/out/refcount/vector.rs
+++ b/tests/unit/out/refcount/vector.rs
@@ -55,17 +55,25 @@ fn main_0() -> i32 {
     };
     assert!(((*v2.borrow()).len() == 3_usize));
     {
-        let idx = (v2.as_pointer() as Ptr<i32>).get_offset();
+        let idx = <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec(
+            (v2.as_pointer() as Ptr<i32>),
+        ))
+        .vec_ptr()
+        .get_offset();
         (v2.as_pointer() as Ptr<Vec<i32>>).with_mut(|__v: &mut Vec<i32>| __v.remove(idx));
-        (v2.as_pointer() as Ptr<Vec<i32>>).decay()
+        RandomAccessIterator::Vec((v2.as_pointer() as Ptr<Vec<i32>>).decay())
     };
     assert!(((*v2.borrow()).len() == 2_usize));
     assert!(({ (*v2.borrow())[0_usize] } == 2));
     assert!(({ (*v2.borrow())[1_usize] } == 3));
     {
-        let __off = (v2.as_pointer() as Ptr<i32>).get_offset();
+        let __off = <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec(
+            (v2.as_pointer() as Ptr<i32>),
+        ))
+        .vec_ptr()
+        .get_offset();
         (*v2.borrow_mut()).insert(__off, 100);
-        (v2.as_pointer() as Ptr<i32>)
+        <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr<i32>)))
     };
     ({ copy_0((*v2.borrow()).clone()) });
     assert!(((*v2.borrow()).len() == 3_usize));
diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs
index 0bd37f294..9af36ebc9 100644
--- a/tests/unit/out/refcount/vector_with_allocator.rs
+++ b/tests/unit/out/refcount/vector_with_allocator.rs
@@ -100,17 +100,25 @@ fn main_0() -> i32 {
     };
     assert!(((*v2.borrow()).len() == 3_usize));
     {
-        let idx = (v2.as_pointer() as Ptr<i32>).get_offset();
+        let idx = <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec(
+            (v2.as_pointer() as Ptr<i32>),
+        ))
+        .vec_ptr()
+        .get_offset();
         (v2.as_pointer() as Ptr<Vec<i32>>).with_mut(|__v: &mut Vec<i32>| __v.remove(idx));
-        (v2.as_pointer() as Ptr<Vec<i32>>).decay()
+        RandomAccessIterator::Vec((v2.as_pointer() as Ptr<Vec<i32>>).decay())
     };
     assert!(((*v2.borrow()).len() == 2_usize));
     assert!(({ (*v2.borrow())[0_usize] } == 2));
     assert!(({ (*v2.borrow())[1_usize] } == 3));
     {
-        let __off = (v2.as_pointer() as Ptr<i32>).get_offset();
+        let __off = <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec(
+            (v2.as_pointer() as Ptr<i32>),
+        ))
+        .vec_ptr()
+        .get_offset();
         (*v2.borrow_mut()).insert(__off, 100);
-        (v2.as_pointer() as Ptr<i32>)
+        <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr<i32>)))
     };
     ({ copy_0((*v2.borrow()).clone()) });
     assert!(((*v2.borrow()).len() == 3_usize));
diff --git a/tests/unit/out/refcount/void_return.rs b/tests/unit/out/refcount/void_return.rs
index c363d00fd..a83d7348a 100644
--- a/tests/unit/out/refcount/void_return.rs
+++ b/tests/unit/out/refcount/void_return.rs
@@ -6,8 +6,49 @@ use std::io::prelude::*;
 use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
-pub fn f1_0(mut first: Ptr<i32>, mut last: Ptr<i32>) {
-    first.sort(last.get_offset());
+pub fn f1_0(first: RandomAccessIterator<i32>, last: RandomAccessIterator<i32>) {
+    let first: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(first));
+    let last: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(last));
+    {
+        let __n = (*last.borrow())
+            .clone()
+            .iter_distance(&(*first.borrow()).clone());
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*first.borrow()).clone().iter_at(__x).with(|__a| {
+                (*first.borrow())
+                    .clone()
+                    .iter_at(__y)
+                    .with(|__b| __a.cmp(__b))
+            })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| (*first.borrow()).clone().iter_at(__i).read())
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            (*first.borrow()).clone().iter_at(__i).write(__v);
+        }
+    };
+    return;
+}
+pub fn f1_1(mut first: Ptr<i32>, mut last: Ptr<i32>) {
+    {
+        let __n = last.iter_distance(&first);
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            first
+                .iter_at(__x)
+                .with(|__a| first.iter_at(__y).with(|__b| __a.cmp(__b)))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| first.iter_at(__i).read())
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            first.iter_at(__i).write(__v);
+        }
+    };
     return;
 }
 pub fn main() {
@@ -17,10 +58,18 @@ pub fn main() {
 fn main_0() -> i32 {
     let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 3, 0, 2, 8, 7]));
     ({
-        let _first: Ptr<i32> = (v.as_pointer() as Ptr<i32>);
-        let _last: Ptr<i32> = (v.as_pointer() as Ptr<i32>).to_end();
+        let _first: RandomAccessIterator<i32> =
+            RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>));
+        let _last: RandomAccessIterator<i32> =
+            RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end());
         f1_0(_first, _last)
     });
+    let a: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2, 3])));
+    ({
+        let _first: Ptr<i32> = (a.as_pointer() as Ptr<i32>);
+        let _last: Ptr<i32> = (a.as_pointer() as Ptr<i32>).offset((2) as isize);
+        f1_1(_first, _last)
+    });
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
index a744210f7..b962a6cfe 100644
--- a/tests/unit/out/unsafe/clone_vs_move.rs
+++ b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -166,46 +166,24 @@ unsafe fn main_0() -> i32 {
         }
         i.prefix_inc();
     }
-    let mut map1: BTreeMap<i32, Box<(i32, i32)>> = BTreeMap::new();
+    let mut map1: UnsafeMap<i32, (i32, i32)> = UnsafeMap::new();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        (*&mut map1
-            .entry(i.clone())
-            .or_insert_with(|| Box::new((i, <i32>::default())))
-            .1) = i;
+        (*&mut (*map1.get_or_insert_with(i.clone(), || (i, <i32>::default()))).1) = i;
         i.prefix_inc();
     }
-    let mut map2: BTreeMap<i32, Box<(i32, i32)>> = map1.clone();
+    let mut map2: UnsafeMap<i32, (i32, i32)> = map1.clone();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        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();
+        assert!(((*&mut (*map2.get_or_insert_with(i.clone(), || (i, <i32>::default()))).1) == (i)));
+        (*&mut (*map2.get_or_insert_with(i.clone(), || (i, <i32>::default()))).1).prefix_inc();
         i.prefix_inc();
     }
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
+        assert!(((*&mut (*map1.get_or_insert_with(i.clone(), || (i, <i32>::default()))).1) == (i)));
         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)
+            ((*&mut (*map2.get_or_insert_with(i.clone(), || (i, <i32>::default()))).1)
                 == ((i) + (1)))
         );
         i.prefix_inc();
diff --git a/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs b/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs
index ddbf28195..6d71bdde7 100644
--- a/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs
+++ b/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs
@@ -22,15 +22,17 @@ unsafe fn main_0() -> i32 {
         let __a1 = 7;
         v.push(__a1)
     };
-    let mut it: *mut i32 = {
-        let mut it = v.as_mut_ptr();
-        while it != v.as_mut_ptr().add(v.len()) && *it != 7 {
-            it = it.add(1);
+    let mut it: UnsafeRandomAccessIterator<i32> = {
+        let mut __it = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr());
+        while __it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()))
+            && *__it.iter_deref() != 7
+        {
+            __it.iter_inc();
         }
-        it
+        __it
     };
-    assert!(it != v.as_mut_ptr().add(v.len()));
-    assert!(((*it) == (7)));
+    assert!(it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())));
+    assert!(((*it.iter_deref()) == (7)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/find.rs b/tests/unit/out/unsafe/find.rs
index c2a3a498c..ca95dc517 100644
--- a/tests/unit/out/unsafe/find.rs
+++ b/tests/unit/out/unsafe/find.rs
@@ -26,71 +26,71 @@ unsafe fn main_0() -> i32 {
         let __a1 = 3;
         v.push(__a1)
     };
-    let mut v_begin: *mut i32 = v.as_mut_ptr();
-    let mut v_end: *mut i32 = v.as_mut_ptr().add(v.len());
-    let mut it: *mut i32 = {
-        let mut it = v_begin;
-        while it != v_end && *it != 2 {
-            it = it.add(1);
+    let mut v_begin: UnsafeRandomAccessIterator<i32> =
+        UnsafeRandomAccessIterator::Vec(v.as_mut_ptr());
+    let mut v_end: UnsafeRandomAccessIterator<i32> =
+        UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()));
+    let mut it: UnsafeRandomAccessIterator<i32> = {
+        let mut __it = (v_begin).clone();
+        while __it != (v_end).clone() && *__it.iter_deref() != 2 {
+            __it.iter_inc();
         }
-        it
+        __it
     };
-    let mut v_result_true: bool = it != v.as_mut_ptr().add(v.len());
-    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<(i32, f64)>>);
-    let mut m_end: UnsafeMapIterator<i32, f64> =
-        UnsafeMapIterator::end(&m as *const BTreeMap<i32, Box<(i32, f64)>>);
+    let mut v_result_true: bool =
+        it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()));
+    let mut m: UnsafeMap<i32, (i32, f64)> = UnsafeMap::new();
+    (*&mut (*m.get_or_insert_with(1.clone(), || (1, <f64>::default()))).1) = 1_f64;
+    (*&mut (*m.get_or_insert_with(2.clone(), || (2, <f64>::default()))).1) = 2_f64;
+    (*&mut (*m.get_or_insert_with(3.clone(), || (3, <f64>::default()))).1) = 3_f64;
+    let mut m_begin: UnsafeBidirectionalIterator<(i32, f64)> = m.begin();
+    let mut m_end: UnsafeBidirectionalIterator<(i32, f64)> = m.end();
     let mut m_result_true: bool = m_begin != m_end;
     assert!(
         ((v_result_true) && (m_result_true))
             && ({
-                let mut it = v.as_mut_ptr();
-                while it != v.as_mut_ptr() && *it != 2 {
-                    it = it.add(1);
+                let mut __it = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr());
+                while __it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr())
+                    && *__it.iter_deref() != 2
+                {
+                    __it.iter_inc();
                 }
-                it
-            } == v.as_mut_ptr())
+                __it
+            } == UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()))
     );
     let mut w: Vec<i32> = vec![1, 2, 3, 4, 5];
     assert!(
         {
-            let mut it = w.as_mut_ptr().add(2_i64 as usize);
-            while it != w.as_mut_ptr().add(w.len()) && *it != 4 {
-                it = it.add(1);
+            let mut __it = UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(2_isize);
+            while __it != UnsafeRandomAccessIterator::Vec(w.as_mut_ptr().add(w.len()))
+                && *__it.iter_deref() != 4
+            {
+                __it.iter_inc();
             }
-            it
-        } == w.as_mut_ptr().add(3_i64 as usize)
+            __it
+        } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(3_isize)
     );
     assert!(
         {
-            let mut it = w.as_mut_ptr().add(2_i64 as usize);
-            while it != w.as_mut_ptr().add(w.len()) && *it != 1 {
-                it = it.add(1);
+            let mut __it = UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(2_isize);
+            while __it != UnsafeRandomAccessIterator::Vec(w.as_mut_ptr().add(w.len()))
+                && *__it.iter_deref() != 1
+            {
+                __it.iter_inc();
             }
-            it
-        } == w.as_mut_ptr().add(w.len())
+            __it
+        } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr().add(w.len()))
     );
     assert!(
         {
-            let mut it = w.as_mut_ptr().add(2_i64 as usize);
-            while it != w.as_mut_ptr().add(4_i64 as usize) && *it != 5 {
-                it = it.add(1);
+            let mut __it = UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(2_isize);
+            while __it != UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(4_isize)
+                && *__it.iter_deref() != 5
+            {
+                __it.iter_inc();
             }
-            it
-        } == w.as_mut_ptr().add(4_i64 as usize)
+            __it
+        } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(4_isize)
     );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/fn_ptr_stable_sort.rs b/tests/unit/out/unsafe/fn_ptr_stable_sort.rs
index 833f02d2e..814c7ced9 100644
--- a/tests/unit/out/unsafe/fn_ptr_stable_sort.rs
+++ b/tests/unit/out/unsafe/fn_ptr_stable_sort.rs
@@ -36,20 +36,32 @@ unsafe fn main_0() -> i32 {
         v.push(__a1)
     };
     {
-        let len = v.as_mut_ptr().add(v.len()).offset_from(v.as_mut_ptr()) as usize;
-        ::std::slice::from_raw_parts_mut(v.as_mut_ptr(), len).sort_by(|x, y| {
-            if (Compare_0 as unsafe fn(*const Item, *const Item) -> bool)
-                .call(x as *const _, y as *const _)
-            {
+        let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()))
+            .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            let __a = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__x) as *const _;
+            let __b = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__y) as *const _;
+            if (Compare_0 as unsafe fn(*const Item, *const Item) -> bool).call(__a, __b) {
                 std::cmp::Ordering::Less
-            } else if (Compare_0 as unsafe fn(*const Item, *const Item) -> bool)
-                .call(y as *const _, x as *const _)
-            {
+            } else if (Compare_0 as unsafe fn(*const Item, *const Item) -> bool).call(__b, __a) {
                 std::cmp::Ordering::Greater
             } else {
                 std::cmp::Ordering::Equal
             }
-        })
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                std::ptr::read(UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i))
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(
+                UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i),
+                __v,
+            );
+        }
     };
     assert!(((v[(0_usize)].key) == (1)));
     assert!(((v[(1_usize)].key) == (2)));
diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs
index d61b91f92..f959c4322 100644
--- a/tests/unit/out/unsafe/foreach_map.rs
+++ b/tests/unit/out/unsafe/foreach_map.rs
@@ -13,36 +13,34 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut m: BTreeMap<i32, Box<(i32, f64)>> = BTreeMap::new();
+    let mut m: UnsafeMap<i32, (i32, f64)> = UnsafeMap::new();
     let mut i: i32 = 0;
     let mut k: i32 = 100;
     'loop_: while ((i) < (100)) {
-        (*&mut m
-            .entry(i.clone())
-            .or_insert_with(|| Box::new((i, <f64>::default())))
-            .1) = ((k as f64) / (2_f64));
+        (*&mut (*m.get_or_insert_with(i.clone(), || (i, <f64>::default()))).1) =
+            ((k as f64) / (2_f64));
         {
             i.prefix_inc();
             k.prefix_dec()
         };
     }
     let mut sum: f64 = 0_f64;
-    'loop_: for __begin1 in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, f64)>>) {
-        let i: *const (i32, f64) = &(*__begin1.deref());
+    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, f64)>) {
+        let i: *const (i32, f64) = &(*__begin1.iter_deref());
         sum += (*i).1;
     }
-    'loop_: for __begin1 in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, f64)>>) {
-        let mut i: (i32, f64) = (*__begin1.deref()).clone();
+    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, f64)>) {
+        let mut i: (i32, f64) = (*__begin1.iter_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();
+    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, f64)>) {
+        let mut i: (i32, f64) = (*__begin1.iter_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());
+    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, f64)>) {
+        let i: *const (i32, f64) = &(*__begin1.iter_deref());
         assert!((((*i).1) != (-1_i32 as f64)));
     }
     return 0;
diff --git a/tests/unit/out/unsafe/inet_pton_ntop.rs b/tests/unit/out/unsafe/inet_pton_ntop.rs
index b93e1c1cb..30ef355ba 100644
--- a/tests/unit/out/unsafe/inet_pton_ntop.rs
+++ b/tests/unit/out/unsafe/inet_pton_ntop.rs
@@ -17,16 +17,19 @@ pub unsafe fn test_s6_addr_access_0() {
         if 16_usize != 0 {
             ::std::ptr::copy_nonoverlapping(
                 (loopback.as_ptr() as *const ::libc::c_void),
-                ((*&raw mut (*&mut addr).s6_addr).as_mut_ptr() as *mut ::libc::c_void),
+                ((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr()
+                    as *mut ::libc::c_void),
                 16_usize as usize,
             )
         }
-        ((*&raw mut (*&mut addr).s6_addr).as_mut_ptr() as *mut ::libc::c_void)
+        ((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr()
+            as *mut ::libc::c_void)
     };
     assert!(
         (((({
             let sa = core::slice::from_raw_parts(
-                ((*&raw mut (*ap).s6_addr).as_mut_ptr() as *const ::libc::c_void) as *const u8,
+                ((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr()
+                    as *const ::libc::c_void) as *const u8,
                 16_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
@@ -44,39 +47,58 @@ pub unsafe fn test_s6_addr_access_0() {
         }) == (0)) as i32)
             != 0)
     );
-    (*&raw mut (*&mut addr).s6_addr)[(0) as usize] = 32_u8;
-    (*&raw mut (*ap).s6_addr)[(1) as usize] = 1_u8;
+    (*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(0) as usize] = 32_u8;
+    (*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(1) as usize] = 1_u8;
     assert!(
-        ((((((((*&raw mut (*&mut addr).s6_addr)[(0) as usize] as i32) == (32)) as i32) != 0)
-            && (((((*&raw mut (*ap).s6_addr)[(1) as usize] as i32) == (1)) as i32) != 0))
-            as i32)
+        ((((((((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(0) as usize] as i32)
+            == (32)) as i32)
+            != 0)
+            && (((((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(1) as usize] as i32)
+                == (1)) as i32)
+                != 0)) as i32)
+            != 0)
+    );
+    (*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(15) as usize] =
+        (((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(15) as usize] as i32) + 4)
+            as u8;
+    (*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(15) as usize].postfix_inc();
+    assert!(
+        (((((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(15) as usize] as i32)
+            == (6)) as i32)
             != 0)
     );
-    (*&raw mut (*&mut addr).s6_addr)[(15) as usize] =
-        (((*&raw mut (*&mut addr).s6_addr)[(15) as usize] as i32) + 4) as u8;
-    (*&raw mut (*ap).s6_addr)[(15) as usize].postfix_inc();
-    assert!((((((*&raw mut (*&mut addr).s6_addr)[(15) as usize] as i32) == (6)) as i32) != 0));
-    let mut bytes: *mut u8 = (*&raw mut (*&mut addr).s6_addr).as_mut_ptr();
+    let mut bytes: *mut u8 =
+        (*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr();
     (*bytes.offset((2) as isize)) = 7_u8;
-    assert!((((((*&raw mut (*ap).s6_addr)[(2) as usize] as i32) == (7)) as i32) != 0));
-    let mut fourth: *mut u8 = (&mut (*&raw mut (*ap).s6_addr)[(3) as usize] as *mut u8);
+    assert!(
+        (((((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(2) as usize] as i32) == (7))
+            as i32)
+            != 0)
+    );
+    let mut fourth: *mut u8 =
+        (&mut (*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr)[(3) as usize] as *mut u8);
     (*fourth) = 8_u8;
-    assert!((((((*&raw mut (*&mut addr).s6_addr)[(3) as usize] as i32) == (8)) as i32) != 0));
+    assert!(
+        (((((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr)[(3) as usize] as i32)
+            == (8)) as i32)
+            != 0)
+    );
     {
         if 16_usize != 0 {
             ::std::ptr::copy_nonoverlapping(
                 (loopback.as_ptr() as *const ::libc::c_void),
-                ((*&raw mut (*ap).s6_addr).as_mut_ptr() as *mut ::libc::c_void),
+                ((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr()
+                    as *mut ::libc::c_void),
                 16_usize as usize,
             )
         }
-        ((*&raw mut (*ap).s6_addr).as_mut_ptr() as *mut ::libc::c_void)
+        ((*&raw mut (*(ap as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr() as *mut ::libc::c_void)
     };
     assert!(
         (((({
             let sa = core::slice::from_raw_parts(
-                ((*&raw mut (*&mut addr).s6_addr).as_mut_ptr() as *const ::libc::c_void)
-                    as *const u8,
+                ((*&raw mut (*(&mut addr as *mut ::libc::in6_addr)).s6_addr).as_mut_ptr()
+                    as *const ::libc::c_void) as *const u8,
                 16_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
diff --git a/tests/unit/out/unsafe/iterator_freshness.rs b/tests/unit/out/unsafe/iterator_freshness.rs
index cfb061d00..a3ddb1f65 100644
--- a/tests/unit/out/unsafe/iterator_freshness.rs
+++ b/tests/unit/out/unsafe/iterator_freshness.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn foo_0(mut a0: *mut i32) {}
+pub unsafe fn foo_0(mut a0: UnsafeRandomAccessIterator<i32>) {}
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -17,8 +17,9 @@ unsafe fn main_0() -> i32 {
     let mut vec_: Vec<i32> = (0..(4_usize) as usize)
         .map(|_| <i32>::default())
         .collect::<Vec<_>>();
-    let mut it: *mut i32 = vec_.as_mut_ptr();
-    (unsafe { foo_0(it) });
+    let mut it: UnsafeRandomAccessIterator<i32> =
+        UnsafeRandomAccessIterator::Vec(vec_.as_mut_ptr());
+    (unsafe { foo_0((it).clone()) });
     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 6e57fced7..aeb19296b 100644
--- a/tests/unit/out/unsafe/map-reallocation.rs
+++ b/tests/unit/out/unsafe/map-reallocation.rs
@@ -15,16 +15,12 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let N: i32 = 10000;
     let sentinel: i32 = ((N) / (2));
-    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, i32)>>, &sentinel);
-    let mut p: *mut i32 = (&mut (*&raw mut (*it.deref()).1) as *mut i32);
+    let mut m: UnsafeMap<i32, (i32, i32)> = UnsafeMap::new();
+    (*&mut (*m.get_or_insert_with(sentinel.clone(), || (sentinel, <i32>::default()))).1) = sentinel;
+    let mut it: UnsafeBidirectionalIterator<(i32, i32)> = m.find(&sentinel);
+    let mut p: *mut i32 = (&mut (*it.iter_deref()).1 as *mut i32);
     assert!(
-        ((*&raw mut (*it.deref()).1) == (sentinel))
+        (((*it.iter_deref()).1) == (sentinel))
             && (!(c"iterator does not have correct value before insert".as_ptr()).is_null())
     );
     assert!(
@@ -33,46 +29,37 @@ unsafe fn main_0() -> i32 {
     );
     let mut i: i32 = 0;
     'loop_: while ((i) < (sentinel)) {
-        (*&mut m
-            .entry(i.clone())
-            .or_insert_with(|| Box::new((i, <i32>::default())))
-            .1) = i;
+        (*&mut (*m.get_or_insert_with(i.clone(), || (i, <i32>::default()))).1) = i;
         i.prefix_inc();
     }
     let mut i: i32 = ((sentinel) + (1));
     'loop_: while ((i) <= (N)) {
-        (*&mut m
-            .entry(i.clone())
-            .or_insert_with(|| Box::new((i, <i32>::default())))
-            .1) = i;
+        (*&mut (*m.get_or_insert_with(i.clone(), || (i, <i32>::default()))).1) = i;
         i.prefix_inc();
     }
     assert!(
-        ((*&raw mut (*it.deref()).1) != (0))
+        (((*it.iter_deref()).1) != (0))
             && (!(c"in refcount, iterator points to index 0 instead of sentinel".as_ptr())
                 .is_null())
     );
     assert!(
-        ((*&raw mut (*it.deref()).1) == (sentinel))
+        (((*it.iter_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())
     );
-    (*&raw mut (*it.deref()).1) = 57005;
+    (*it.iter_deref()).1 = 57005;
     assert!(
-        ((*&mut m
-            .entry(sentinel.clone())
-            .or_insert_with(|| Box::new((sentinel, <i32>::default())))
-            .1)
+        ((*&mut (*m.get_or_insert_with(sentinel.clone(), || (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 __begin1 in UnsafeMapIterator::begin(&m as *const BTreeMap<i32, Box<(i32, i32)>>) {
-        let pair: *mut (i32, i32) = &mut (*__begin1.deref());
+    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, i32)>) {
+        let pair: *mut (i32, i32) = &mut (*__begin1.iter_deref());
         assert!((((*pair).0) > (prev)));
         prev = (*pair).0;
     }
diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs
index 23c31e12e..93a688ead 100644
--- a/tests/unit/out/unsafe/map.rs
+++ b/tests/unit/out/unsafe/map.rs
@@ -19,222 +19,142 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    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;
+    let mut m: UnsafeMap<i16, (i16, u32)> = UnsafeMap::new();
+    (*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, <u32>::default()))).1) = 1_u32;
+    (*&mut (*m.get_or_insert_with(1_i16.clone(), || (1_i16, <u32>::default()))).1) = 2_u32;
+    (*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, <u32>::default()))).1) = 3_u32;
     assert!(((m.len()) == (3_usize)));
     assert!(
-        ((*&mut m
-            .entry(0_i16.clone())
-            .or_insert_with(|| Box::new((0_i16, <u32>::default())))
-            .1)
-            == (1_u32))
+        ((*&mut (*m.get_or_insert_with(0_i16.clone(), || (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))
+        ((*&mut (*m.get_or_insert_with(1_i16.clone(), || (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))
+        ((*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, <u32>::default()))).1) == (3_u32))
     );
     let mut x: i32 = 4;
-    (*&mut m
-        .entry(1_i16.clone())
-        .or_insert_with(|| Box::new((1_i16, <u32>::default())))
-        .1) = (x as u32);
+    (*&mut (*m.get_or_insert_with(1_i16.clone(), || (1_i16, <u32>::default()))).1) = (x as u32);
     assert!(((m.len()) == (3_usize)));
     assert!(
-        ((*&mut m
-            .entry(0_i16.clone())
-            .or_insert_with(|| Box::new((0_i16, <u32>::default())))
-            .1)
-            == (1_u32))
+        ((*&mut (*m.get_or_insert_with(0_i16.clone(), || (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))
+        ((*&mut (*m.get_or_insert_with(1_i16.clone(), || (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))
+        ((*&mut (*m.get_or_insert_with(2_i16.clone(), || (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),
-        )
+        foo_0((*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, <u32>::default()))).1))
     });
     assert!(
-        ((*&mut m
-            .entry(0_i16.clone())
-            .or_insert_with(|| Box::new((0_i16, <u32>::default())))
-            .1)
-            == (1_u32))
+        ((*&mut (*m.get_or_insert_with(0_i16.clone(), || (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),
-        )
+        bar_1(&mut (*&mut (*m.get_or_insert_with(2_i16.clone(), || (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.get_or_insert_with(2_i16.clone(), || (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),
-        );
+    (*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, <u32>::default()))).1) =
+        (*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, <u32>::default()))).1)
+            .wrapping_add(
+                (*&mut (*m.get_or_insert_with(2_i16.clone(), || (2_i16, <u32>::default()))).1),
+            );
     assert!(
-        ((*&mut m
-            .entry(0_i16.clone())
-            .or_insert_with(|| Box::new((0_i16, <u32>::default())))
-            .1)
-            == (5_u32))
+        ((*&mut (*m.get_or_insert_with(0_i16.clone(), || (0_i16, <u32>::default()))).1) == (5_u32))
     );
-    let mut end: UnsafeMapIterator<i16, 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<(i16, u32)>>, &1_i16);
-    let mut const_it: UnsafeMapIterator<i16, u32> =
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<(i16, u32)>>, &10_i16).clone();
+    let mut end: UnsafeBidirectionalIterator<(i16, u32)> = m.end();
+    let mut it: UnsafeBidirectionalIterator<(i16, u32)> = m.find(&1_i16);
+    let mut const_it: UnsafeBidirectionalIterator<(i16, u32)> =
+        <UnsafeBidirectionalIterator<(i16, u32)>>::from(m.find(&10_i16));
     let mut x1: u32 = if it == end {
         0_u32
     } else {
-        (*&raw mut (*it.deref()).1)
+        (*it.iter_deref()).1
     };
     assert!(((x1) == (4_u32)));
-    let mut x2: u32 = if const_it == end.clone() {
+    let mut x2: u32 = if const_it == <UnsafeBidirectionalIterator<(i16, u32)>>::from((end).clone())
+    {
         0_u32
     } else {
-        (*&raw mut (*const_it.deref()).1)
+        (*const_it.iter_deref()).1
     };
     assert!(((x2) == (0_u32)));
-    let mut x3: u32 = if it == UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<(i16, u32)>>) {
+    let mut x3: u32 = if it == m.end() {
         0_u32
     } else {
-        (*&raw mut (*it.deref()).1)
+        (*it.iter_deref()).1
     };
     assert!(((x3) == (4_u32)));
-    let mut x4: u32 = if const_it
-        == UnsafeMapIterator::end(&m as *const BTreeMap<i16, Box<(i16, u32)>>).clone()
-    {
+    let mut x4: u32 = if const_it == <UnsafeBidirectionalIterator<(i16, u32)>>::from(m.end()) {
         0_u32
     } else {
-        (*&raw mut (*const_it.deref()).1)
+        (*const_it.iter_deref()).1
     };
     assert!(((x4) == (0_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<(i16, u32)>>, &4_i16);
-    let mut p: *mut u32 = (&mut (*&raw mut (*it4.deref()).1) as *mut u32);
+    (*&mut (*m.get_or_insert_with(4_i16.clone(), || (4_i16, <u32>::default()))).1) = 5_u32;
+    let mut it4: UnsafeBidirectionalIterator<(i16, u32)> = m.find(&4_i16);
+    let mut p: *mut u32 = (&mut (*it4.iter_deref()).1 as *mut u32);
     let mut x5: u32 = (*p);
     assert!(
-        ((*&mut m
-            .entry(4_i16.clone())
-            .or_insert_with(|| Box::new((4_i16, <u32>::default())))
-            .1)
-            == (5_u32))
+        ((*&mut (*m.get_or_insert_with(4_i16.clone(), || (4_i16, <u32>::default()))).1) == (5_u32))
     );
-    assert!(((*&raw mut (*it4.deref()).1) == (5_u32)));
+    assert!((((*it4.iter_deref()).1) == (5_u32)));
     assert!(((*p) == (5_u32)));
     assert!(((x5) == (5_u32)));
     (*p).prefix_inc();
     assert!(
-        ((*&mut m
-            .entry(4_i16.clone())
-            .or_insert_with(|| Box::new((4_i16, <u32>::default())))
-            .1)
-            == (6_u32))
+        ((*&mut (*m.get_or_insert_with(4_i16.clone(), || (4_i16, <u32>::default()))).1) == (6_u32))
     );
-    assert!(((*&raw mut (*it4.deref()).1) == (6_u32)));
+    assert!((((*it4.iter_deref()).1) == (6_u32)));
     assert!(((*p) == (6_u32)));
     assert!(((x5) == (5_u32)));
-    let mut const_it4: UnsafeMapIterator<i16, u32> =
-        UnsafeMapIterator::find_key(&m as *const BTreeMap<i16, Box<(i16, u32)>>, &4_i16).clone();
-    assert!((((*const_it4.deref().cast_const()).1) == (6_u32)));
-    let r: *mut BTreeMap<i16, Box<(i16, u32)>> = &mut m;
+    let mut const_it4: UnsafeBidirectionalIterator<(i16, u32)> =
+        <UnsafeBidirectionalIterator<(i16, u32)>>::from(m.find(&4_i16));
+    assert!((((*const_it4.iter_deref()).1) == (6_u32)));
+    let r: *mut UnsafeMap<i16, (i16, u32)> = &mut m;
     assert!((((*r).len()) == (4_usize)));
-    assert!(
-        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<(i16, u32)>>, &it4.clone());
+    assert!(m.find(&4_i16) != m.end());
+    (*r).erase(&(it4).clone());
     assert!((((*r).len()) == (3_usize)));
-    assert!(
-        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<((i32, i64), f64)>> = BTreeMap::new();
+    assert!(m.find(&4_i16) == m.end());
+    (*&mut (*m.get_or_insert_with(7_i16.clone(), || (7_i16, <u32>::default()))).1) = 7_u32;
+    (*&mut (*m.get_or_insert_with(8_i16.clone(), || (8_i16, <u32>::default()))).1) = 8_u32;
+    (*&mut (*m.get_or_insert_with(9_i16.clone(), || (9_i16, <u32>::default()))).1) = 9_u32;
+    assert!((((*r).len()) == (6_usize)));
+    assert!(((m.erase_key(&10_i16)) == (0_usize)));
+    let mut key9: i32 = 9;
+    assert!(((m.erase_key(&(key9 as i16))) == (1_usize)));
+    assert!((((*r).len()) == (5_usize)));
+    let mut cit: UnsafeBidirectionalIterator<(i16, u32)> =
+        <UnsafeBidirectionalIterator<(i16, u32)>>::from(m.find(&7_i16));
+    let mut next: UnsafeBidirectionalIterator<(i16, u32)> = m.erase(&(cit).clone());
+    assert!(next == m.find(&8_i16));
+    next = m.erase(&(next).clone());
+    assert!(next == m.end());
+    assert!((((*r).len()) == (3_usize)));
+    assert!(m.find(&8_i16) == m.end());
+    let mut other_map: UnsafeMap<(i32, i64), ((i32, i64), f64)> = UnsafeMap::new();
     assert!(((other_map.len()) == (0_usize)));
     let mut key0: (i32, i64) = (1.into(), 1.into());
     let mut value: f64 = 2_f64;
-    (*&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);
+    (*&mut (*other_map.get_or_insert_with(key0.clone(), || (key0, <f64>::default()))).1) = value;
+    value = (*&mut (*other_map.get_or_insert_with(key0.clone(), || (key0, <f64>::default()))).1);
     assert!(((other_map.len()) == (1_usize)));
     assert!(
-        ((*&mut other_map
-            .entry(key0.clone())
-            .or_insert_with(|| Box::new((key0, <f64>::default())))
-            .1)
+        ((*&mut (*other_map.get_or_insert_with(key0.clone(), || (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!").1 as *const u32)) == (5_u32)));
+    assert!(((*&raw const (*m.get(&(k as i16)).expect("out of range!")).1) == (5_u32)));
     k.prefix_inc();
-    assert!(((*(&m.get(&(k as i16)).expect("out of range!").1 as *const u32)) == (4_u32)));
+    assert!(((*&raw const (*m.get(&(k as i16)).expect("out of range!")).1) == (4_u32)));
     k.prefix_inc();
-    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!(((*&raw const (*m.get(&(k as i16)).expect("out of range!")).1) == (4_u32)));
+    let mut m2: UnsafeMap<i32, (i32, bool)> = UnsafeMap::new();
     assert!(((m2.len()) == (0_usize)));
     let mut indexes: Vec<i32> = Vec::new();
     let mut i: u32 = 60_u32;
@@ -263,23 +183,22 @@ unsafe fn main_0() -> i32 {
     }
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < (indexes.len())) {
-        (*&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);
+        (*&mut (*m2.get_or_insert_with(indexes[(i as usize)].clone(), || {
+            (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 __begin1 in UnsafeMapIterator::begin(&m2 as *const BTreeMap<i32, Box<(i32, bool)>>)
-    {
-        let pair: *mut (i32, bool) = &mut (*__begin1.deref());
+    'loop_: for __begin1 in UnsafeMap::range(&m2 as *const UnsafeMap<i32, (i32, bool)>) {
+        let pair: *mut (i32, bool) = &mut (*__begin1.iter_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!").1 as *const u32);
+    let value_0: *const u32 = &raw const (*m.get(&(k as i16)).expect("out of range!")).1;
     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/max.rs b/tests/unit/out/unsafe/max.rs
index 998be89d7..e878c24e8 100644
--- a/tests/unit/out/unsafe/max.rs
+++ b/tests/unit/out/unsafe/max.rs
@@ -51,20 +51,18 @@ unsafe fn main_0() -> i32 {
     assert!(((((((r1) + (r2)) + (r3)) + (r4)) + (r5)) == (56)));
     let mut values: [i32; 4] = [1, 7, 7, 3];
     let mut max: *mut i32 = {
-        let count = values
-            .as_mut_ptr()
-            .offset((4) as isize)
-            .offset_from(values.as_mut_ptr()) as usize;
-        std::slice::from_raw_parts(values.as_mut_ptr(), count)
-            .iter()
-            .enumerate()
-            .max_by(|(idx_a, x), (idx_b, y)| {
-                x.partial_cmp(y)
-                    .unwrap_or(std::cmp::Ordering::Equal)
-                    .then_with(|| idx_b.cmp(idx_a))
-            })
-            .map(|(i, _)| values.as_mut_ptr().add(i))
-            .unwrap_or(values.as_mut_ptr())
+        let mut __best = values.as_mut_ptr().clone();
+        if values.as_mut_ptr() != values.as_mut_ptr().offset((4) as isize) {
+            let mut __it = values.as_mut_ptr();
+            __it.iter_inc();
+            while __it != values.as_mut_ptr().offset((4) as isize) {
+                if *__best.iter_deref() < *__it.iter_deref() {
+                    __best = __it.clone();
+                }
+                __it.iter_inc();
+            }
+        }
+        __best
     };
     assert!(((max) == (values.as_mut_ptr().offset((1) as isize))));
     return 0;
diff --git a/tests/unit/out/unsafe/operator_comparison_nonbool.rs b/tests/unit/out/unsafe/operator_comparison_nonbool.rs
index 75f54f680..e72ac1d5a 100644
--- a/tests/unit/out/unsafe/operator_comparison_nonbool.rs
+++ b/tests/unit/out/unsafe/operator_comparison_nonbool.rs
@@ -263,11 +263,21 @@ unsafe fn main_0() -> i32 {
     );
     let mut xs: [X; 3] = [X { v: 3 }, X { v: 1 }, X { v: 2 }];
     {
-        let len = xs
+        let __n = xs
             .as_mut_ptr()
             .offset((3) as isize)
-            .offset_from(xs.as_mut_ptr()) as usize;
-        ::std::slice::from_raw_parts_mut(xs.as_mut_ptr(), len).sort()
+            .iter_distance(&xs.as_mut_ptr());
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*xs.as_mut_ptr().iter_at(__x)).cmp(&*xs.as_mut_ptr().iter_at(__y))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| std::ptr::read(xs.as_mut_ptr().iter_at(__i)))
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(xs.as_mut_ptr().iter_at(__i), __v);
+        }
     };
     assert!(
         (((xs[(0) as usize].v) == (1)) && ((xs[(1) as usize].v) == (2)))
@@ -283,11 +293,21 @@ unsafe fn main_0() -> i32 {
     assert!((((unsafe { Mixed::operator_cmp(&m, &n,) }).r) == (0)));
     let mut ms: [Mixed; 3] = [Mixed { v: 6 }, Mixed { v: 4 }, Mixed { v: 5 }];
     {
-        let len = ms
+        let __n = ms
             .as_mut_ptr()
             .offset((3) as isize)
-            .offset_from(ms.as_mut_ptr()) as usize;
-        ::std::slice::from_raw_parts_mut(ms.as_mut_ptr(), len).sort()
+            .iter_distance(&ms.as_mut_ptr());
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*ms.as_mut_ptr().iter_at(__x)).cmp(&*ms.as_mut_ptr().iter_at(__y))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| std::ptr::read(ms.as_mut_ptr().iter_at(__i)))
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(ms.as_mut_ptr().iter_at(__i), __v);
+        }
     };
     assert!(
         (((ms[(0) as usize].v) == (4)) && ((ms[(1) as usize].v) == (5)))
@@ -328,11 +348,21 @@ unsafe fn main_0() -> i32 {
     assert!(lt.value);
     let mut bs: [Boolish; 3] = [Boolish { v: 3 }, Boolish { v: 1 }, Boolish { v: 2 }];
     {
-        let len = bs
+        let __n = bs
             .as_mut_ptr()
             .offset((3) as isize)
-            .offset_from(bs.as_mut_ptr()) as usize;
-        ::std::slice::from_raw_parts_mut(bs.as_mut_ptr(), len).sort()
+            .iter_distance(&bs.as_mut_ptr());
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*bs.as_mut_ptr().iter_at(__x)).cmp(&*bs.as_mut_ptr().iter_at(__y))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| std::ptr::read(bs.as_mut_ptr().iter_at(__i)))
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(bs.as_mut_ptr().iter_at(__i), __v);
+        }
     };
     assert!(
         (((bs[(0) as usize].v) == (1)) && ((bs[(1) as usize].v) == (2)))
@@ -344,11 +374,11 @@ unsafe fn main_0() -> i32 {
     let mut ris: [RefInt; 2] = [RefInt { v: 1 }, RefInt { v: 2 }];
     assert!(
         (({
-            let mut it = ris.as_mut_ptr();
-            while it != ris.as_mut_ptr().offset((2) as isize) && *it != ri2 {
-                it = it.add(1);
+            let mut __it = ris.as_mut_ptr();
+            while __it != ris.as_mut_ptr().offset((2) as isize) && *__it.iter_deref() != ri2 {
+                __it.iter_inc();
             }
-            it
+            __it
         }) == (ris.as_mut_ptr()))
     );
     return 0;
diff --git a/tests/unit/out/unsafe/operator_traits.rs b/tests/unit/out/unsafe/operator_traits.rs
index cf3a90ebb..718531e00 100644
--- a/tests/unit/out/unsafe/operator_traits.rs
+++ b/tests/unit/out/unsafe/operator_traits.rs
@@ -139,11 +139,25 @@ unsafe fn main_0() -> i32 {
     assert!(((w.v) == (2)));
     let mut lts: Vec<Lt> = vec![Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }];
     {
-        let len = lts
-            .as_mut_ptr()
-            .add(lts.len())
-            .offset_from(lts.as_mut_ptr()) as usize;
-        ::std::slice::from_raw_parts_mut(lts.as_mut_ptr(), len).sort()
+        let __n = UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr().add(lts.len()))
+            .iter_distance(&UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__x))
+                .cmp(&*UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__y))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                std::ptr::read(UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__i))
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(
+                UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__i),
+                __v,
+            );
+        }
     };
     assert!(
         (((lts[(0_usize)].v) == (1)) && ((lts[(1_usize)].v) == (2))) && ((lts[(2_usize)].v) == (3))
@@ -153,81 +167,108 @@ unsafe fn main_0() -> i32 {
     let mut nine: Eq = Eq { v: 9 };
     assert!(
         (((*{
-            let mut it = eqs.as_mut_ptr();
-            while it != eqs.as_mut_ptr().add(eqs.len()) && *it != two {
-                it = it.add(1);
+            let mut __it = UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr());
+            while __it != UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len()))
+                && *__it.iter_deref() != two
+            {
+                __it.iter_inc();
             }
-            it
-        })
+            __it
+        }
+        .iter_deref())
         .v) == (2))
     );
     assert!(
         {
-            let mut it = eqs.as_mut_ptr();
-            while it != eqs.as_mut_ptr().add(eqs.len()) && *it != nine {
-                it = it.add(1);
+            let mut __it = UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr());
+            while __it != UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len()))
+                && *__it.iter_deref() != nine
+            {
+                __it.iter_inc();
             }
-            it
-        } == eqs.as_mut_ptr().add(eqs.len())
+            __it
+        } == UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len()))
     );
     let mut cmps: Vec<Cmp> = vec![Cmp { v: 3 }, Cmp { v: 1 }, Cmp { v: 2 }];
     {
-        let len = cmps
-            .as_mut_ptr()
-            .add(cmps.len())
-            .offset_from(cmps.as_mut_ptr()) as usize;
-        ::std::slice::from_raw_parts_mut(cmps.as_mut_ptr(), len).sort()
+        let __n = UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr().add(cmps.len()))
+            .iter_distance(&UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__x))
+                .cmp(&*UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__y))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                std::ptr::read(UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__i))
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(
+                UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__i),
+                __v,
+            );
+        }
     };
     assert!(((cmps[(0_usize)].v) == (1)) && ((cmps[(2_usize)].v) == (3)));
     let mut three: Cmp = Cmp { v: 3 };
     assert!(
         (((*{
-            let mut it = cmps.as_mut_ptr();
-            while it != cmps.as_mut_ptr().add(cmps.len()) && *it != three {
-                it = it.add(1);
+            let mut __it = UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr());
+            while __it != UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr().add(cmps.len()))
+                && *__it.iter_deref() != three
+            {
+                __it.iter_inc();
             }
-            it
-        })
+            __it
+        }
+        .iter_deref())
         .v) == (3))
     );
     let mut frees: Vec<Free> = vec![Free { v: 2 }, Free { v: 1 }];
     {
-        let len = frees
-            .as_mut_ptr()
-            .add(frees.len())
-            .offset_from(frees.as_mut_ptr()) as usize;
-        ::std::slice::from_raw_parts_mut(frees.as_mut_ptr(), len).sort()
+        let __n = UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr().add(frees.len()))
+            .iter_distance(&UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__x))
+                .cmp(&*UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__y))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                std::ptr::read(UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__i))
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(
+                UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__i),
+                __v,
+            );
+        }
     };
     assert!(((frees[(0_usize)].v) == (1)));
     let mut ftwo: Free = Free { v: 2 };
     assert!(
         (((*{
-            let mut it = frees.as_mut_ptr();
-            while it != frees.as_mut_ptr().add(frees.len()) && *it != ftwo {
-                it = it.add(1);
+            let mut __it = UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr());
+            while __it != UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr().add(frees.len()))
+                && *__it.iter_deref() != ftwo
+            {
+                __it.iter_inc();
             }
-            it
-        })
+            __it
+        }
+        .iter_deref())
         .v) == (2))
     );
-    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))
-    );
+    let mut m: UnsafeMap<Lt, (Lt, i32)> = UnsafeMap::new();
+    (*&mut (*m.get_or_insert_with(Lt { v: 2 }.clone(), || (Lt { v: 2 }, <i32>::default()))).1) = 20;
+    (*&mut (*m.get_or_insert_with(Lt { v: 1 }.clone(), || (Lt { v: 1 }, <i32>::default()))).1) = 10;
+    assert!((((*m.begin().iter_deref()).1) == (10)));
     assert!(
-        ((*&mut m
-            .entry(Lt { v: 2 }.clone())
-            .or_insert_with(|| Box::new((Lt { v: 2 }, <i32>::default())))
+        ((*&mut (*m.get_or_insert_with(Lt { v: 2 }.clone(), || (Lt { v: 2 }, <i32>::default())))
             .1)
             == (20))
     );
diff --git a/tests/unit/out/unsafe/pointer_usize_arith.rs b/tests/unit/out/unsafe/pointer_usize_arith.rs
index f3953c319..a5f175322 100644
--- a/tests/unit/out/unsafe/pointer_usize_arith.rs
+++ b/tests/unit/out/unsafe/pointer_usize_arith.rs
@@ -21,8 +21,9 @@ unsafe fn main_0() -> i32 {
     assert!(((*r) == (13)));
     let mut s: *mut i32 = r.offset(-((2) as isize));
     assert!(((*s) == (11)));
-    let mut diff: i64 = ((r as usize - p as usize) / ::std::mem::size_of::<i32>()) as i64;
-    assert!(((diff) == (3_i64)));
+    let mut diff: isize =
+        (((r as usize - p as usize) / ::std::mem::size_of::<i32>()) as i64 as isize);
+    assert!(((diff) == (3_isize)));
     let mut idx: usize =
         ((((r as usize - p as usize) / ::std::mem::size_of::<i32>()) as i64) as usize);
     assert!(((idx) == (3_usize)));
@@ -63,13 +64,15 @@ unsafe fn main_0() -> i32 {
     let mut bp: *mut u8 = bytes.as_mut_ptr();
     let mut bq: *mut u8 = bp.offset((4) as isize);
     assert!((((*bq) as i32) == (4)));
-    let mut bdiff: i64 = ((bq as usize - bp as usize) / ::std::mem::size_of::<u8>()) as i64;
-    assert!(((bdiff) == (4_i64)));
+    let mut bdiff: isize =
+        (((bq as usize - bp as usize) / ::std::mem::size_of::<u8>()) as i64 as isize);
+    assert!(((bdiff) == (4_isize)));
     let mut cp: *const i32 = (arr.as_mut_ptr()).cast_const();
     let mut cq: *const i32 = cp.offset((2) as isize);
     assert!(((*cq) == (12)));
-    let mut cdiff: i64 = ((cq as usize - cp as usize) / ::std::mem::size_of::<i32>()) as i64;
-    assert!(((cdiff) == (2_i64)));
+    let mut cdiff: isize =
+        (((cq as usize - cp as usize) / ::std::mem::size_of::<i32>()) as i64 as isize);
+    assert!(((cdiff) == (2_isize)));
     let mut n: usize = 3_usize;
     let mut q5: *mut i32 = arr.as_mut_ptr().offset((n) as isize);
     assert!(((*q5) == (13)));
diff --git a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
index d83867e19..307b0ed28 100644
--- a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
@@ -6,10 +6,11 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 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() {
-        (*&raw mut (*it.deref()).1)
+pub unsafe fn sink_0(mut it: UnsafeBidirectionalIterator<(i32, i32)>) -> i32 {
+    let mut cit: UnsafeBidirectionalIterator<(i32, i32)> =
+        <UnsafeBidirectionalIterator<(i32, i32)>>::from((it).clone());
+    return if cit == <UnsafeBidirectionalIterator<(i32, i32)>>::from((it).clone()) {
+        (*it.iter_deref()).1
     } else {
         0
     };
@@ -21,18 +22,18 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    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, i32)>>);
-    let mut it0: UnsafeMapIterator<i32, i32> =
-        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()) });
+    let mut m: UnsafeMap<i32, (i32, i32)> = UnsafeMap::new();
+    (*&mut (*m.get_or_insert_with(0.clone(), || (0, <i32>::default()))).1) = 1;
+    let mut end: UnsafeBidirectionalIterator<(i32, i32)> = m.end();
+    let mut it0: UnsafeBidirectionalIterator<(i32, i32)> = m.find(&0);
+    let mut const_it: UnsafeBidirectionalIterator<(i32, i32)> =
+        <UnsafeBidirectionalIterator<(i32, i32)>>::from((it0).clone());
+    let mut r: i32 = if const_it == <UnsafeBidirectionalIterator<(i32, i32)>>::from((end).clone()) {
+        0
+    } else {
+        1
+    };
+    r += (unsafe { sink_0((it0).clone()) });
     r += if end == end { 0 } else { 1 };
     assert!(((r) == (2)));
     return 0;
diff --git a/tests/unit/out/unsafe/sort.rs b/tests/unit/out/unsafe/sort.rs
index c89ba7d9d..fc4469412 100644
--- a/tests/unit/out/unsafe/sort.rs
+++ b/tests/unit/out/unsafe/sort.rs
@@ -55,8 +55,25 @@ unsafe fn main_0() -> i32 {
         v.push(__a1)
     };
     {
-        let len = v.as_mut_ptr().add(v.len()).offset_from(v.as_mut_ptr()) as usize;
-        ::std::slice::from_raw_parts_mut(v.as_mut_ptr(), len).sort()
+        let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()))
+            .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()));
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__x))
+                .cmp(&*UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__y))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| {
+                std::ptr::read(UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i))
+            })
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(
+                UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i),
+                __v,
+            );
+        }
     };
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < ((v.len()).wrapping_sub(1_usize))) {
diff --git a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
index 6eded9e98..2fbfba5d7 100644
--- a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
+++ b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
@@ -14,9 +14,9 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut v: Vec<i32> = vec![1, 2];
-    let mut p: *mut i32 = v.as_mut_ptr();
+    let mut p: UnsafeRandomAccessIterator<i32> = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr());
     let r: *const i32 = &v[(1_usize)];
-    (*p) = (*r);
+    (*p.iter_deref()) = (*r);
     assert!(((v[(0_usize)]) == (2)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/stdcopy.rs b/tests/unit/out/unsafe/stdcopy.rs
index 12a4672c0..16a2654d3 100644
--- a/tests/unit/out/unsafe/stdcopy.rs
+++ b/tests/unit/out/unsafe/stdcopy.rs
@@ -16,14 +16,14 @@ unsafe fn main_0() -> i32 {
     let mut input: [i32; 3] = [1, 2, 3];
     let mut output: [i32; 3] = [0_i32; 3];
     {
-        let mut outptr = output.as_mut_ptr().clone();
-        let mut curr = input.as_mut_ptr().clone();
-        while curr < input.as_mut_ptr().offset((3) as isize) {
-            *outptr = (*curr).clone().into();
-            curr = curr.offset(1);
-            outptr = outptr.offset(1);
+        let mut __first = input.as_mut_ptr();
+        let mut __out = output.as_mut_ptr();
+        while __first != input.as_mut_ptr().offset((3) as isize) {
+            *__out.iter_deref() = (*__first.iter_deref()).clone().into();
+            __first.iter_inc();
+            __out.iter_inc();
         }
-        outptr
+        __out
     };
     return 0;
 }
diff --git a/tests/unit/out/unsafe/sys_stat.rs b/tests/unit/out/unsafe/sys_stat.rs
index 507145aaf..a6930e034 100644
--- a/tests/unit/out/unsafe/sys_stat.rs
+++ b/tests/unit/out/unsafe/sys_stat.rs
@@ -16,7 +16,7 @@ pub unsafe fn test_stat_0() {
     let mut st: ::libc::stat = unsafe { std::mem::zeroed() };
     assert!(((((libc::stat(path, (&mut st as *mut ::libc::stat))) == (0)) as i32) != 0));
     assert!(((((st.st_size) == (5_i64)) as i32) != 0));
-    assert!(((((*&raw mut (*&mut st).st_mtime) > (0_i64)) as i32) != 0));
+    assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) > (0_i64)) as i32) != 0));
     libc::unlink(path);
 }
 pub unsafe fn test_fstat_1() {
@@ -30,31 +30,33 @@ pub unsafe fn test_fstat_1() {
     let mut st: ::libc::stat = unsafe { std::mem::zeroed() };
     assert!(((((libc::fstat(fd, (&mut st as *mut ::libc::stat))) == (0)) as i32) != 0));
     assert!(((((st.st_size) == (11_i64)) as i32) != 0));
-    assert!(((((*&raw mut (*&mut st).st_mtime) > (0_i64)) as i32) != 0));
+    assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) > (0_i64)) as i32) != 0));
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
     libc::unlink(path);
 }
 pub unsafe fn test_st_mtime_access_2() {
     let mut st: ::libc::stat = unsafe { std::mem::zeroed() };
     let mut sp: *mut ::libc::stat = (&mut st as *mut ::libc::stat);
-    (*&raw mut (*&mut st).st_mtime) = 5_i64;
-    assert!(((((*&raw mut (*&mut st).st_mtime) == (5_i64)) as i32) != 0));
-    (*&raw mut (*sp).st_mtime) = 6_i64;
-    assert!(((((*&raw mut (*sp).st_mtime) == (6_i64)) as i32) != 0));
-    (*&raw mut (*&mut st).st_mtime) += 2_i64;
-    assert!(((((*&raw mut (*&mut st).st_mtime) == (8_i64)) as i32) != 0));
-    (*&raw mut (*sp).st_mtime) -= 1_i64;
-    assert!(((((*&raw mut (*sp).st_mtime) == (7_i64)) as i32) != 0));
-    (*&raw mut (*&mut st).st_mtime).postfix_inc();
-    (*&raw mut (*sp).st_mtime).prefix_inc();
-    assert!(((((*&raw mut (*&mut st).st_mtime) == (9_i64)) as i32) != 0));
-    let mut mtime: *mut i64 = (&mut (*&raw mut (*&mut st).st_mtime) as *mut i64);
+    (*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) = 5_i64;
+    assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) == (5_i64)) as i32) != 0));
+    (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) = 6_i64;
+    assert!(((((*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) == (6_i64)) as i32) != 0));
+    (*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) += 2_i64;
+    assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) == (8_i64)) as i32) != 0));
+    (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) -= 1_i64;
+    assert!(((((*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) == (7_i64)) as i32) != 0));
+    (*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime).postfix_inc();
+    (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime).prefix_inc();
+    assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) == (9_i64)) as i32) != 0));
+    let mut mtime: *mut i64 =
+        (&mut (*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) as *mut i64);
     (*mtime) = 10_i64;
-    assert!(((((*&raw mut (*&mut st).st_mtime) == (10_i64)) as i32) != 0));
-    let mut mtime_via_ptr: *mut i64 = (&mut (*&raw mut (*sp).st_mtime) as *mut i64);
+    assert!(((((*&raw mut (*(&mut st as *mut ::libc::stat)).st_mtime) == (10_i64)) as i32) != 0));
+    let mut mtime_via_ptr: *mut i64 =
+        (&mut (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime) as *mut i64);
     (*mtime_via_ptr) = 11_i64;
     assert!(((((*mtime) == (11_i64)) as i32) != 0));
-    let mut copy: i64 = (*&raw mut (*sp).st_mtime);
+    let mut copy: i64 = (*&raw mut (*(sp as *mut ::libc::stat)).st_mtime);
     assert!(((((copy) == (11_i64)) as i32) != 0));
 }
 pub fn main() {
diff --git a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
index 0eefc94f9..6cbbacdec 100644
--- a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
+++ b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
@@ -43,30 +43,35 @@ pub unsafe fn lehmer_2(mut sigma: *const u32, mut len: u32, mut code: *mut u32)
     }
     let mut i: u32 = 0_u32;
     'loop_: while ((i) < (len)) {
-        let mut it: *mut u32 = {
-            let mut it = items.as_mut_ptr();
-            while it != items.as_mut_ptr().add(items.len()) && *it != (*sigma.offset((i) as isize))
+        let mut it: UnsafeRandomAccessIterator<u32> = {
+            let mut __it = UnsafeRandomAccessIterator::Vec(items.as_mut_ptr());
+            while __it != UnsafeRandomAccessIterator::Vec(items.as_mut_ptr().add(items.len()))
+                && *__it.iter_deref() != (*sigma.offset((i) as isize))
             {
-                it = it.add(1);
+                __it.iter_inc();
             }
-            it
+            __it
         };
-        assert!(it != items.as_mut_ptr().add(items.len()));
-        (*code.offset((i) as isize)) = (it.offset_from(items.as_mut_ptr()) as u32);
+        assert!(it != UnsafeRandomAccessIterator::Vec(items.as_mut_ptr().add(items.len())));
+        (*code.offset((i) as isize)) =
+            (it.iter_distance(&UnsafeRandomAccessIterator::Vec(items.as_mut_ptr())) as u32);
         {
-            let pos = it.offset_from(items.as_ptr()) as usize;
+            let pos = <UnsafeRandomAccessIterator<u32>>::from((it).clone())
+                .vec_ptr()
+                .offset_from(items.as_ptr()) as usize;
             items.remove(pos);
-            it
+            <UnsafeRandomAccessIterator<u32>>::from((it).clone())
         };
         i.prefix_inc();
     }
 }
 pub unsafe fn sum_3(v: *mut Vec<i32>) -> i32 {
     let mut s: i32 = 0;
-    let mut it: *mut i32 = (*v).as_mut_ptr();
-    'loop_: while it != (*v).as_mut_ptr().add((*v).len()) {
-        s += (*it);
-        it.prefix_inc();
+    let mut it: UnsafeRandomAccessIterator<i32> =
+        UnsafeRandomAccessIterator::Vec((*v).as_mut_ptr());
+    'loop_: while it != UnsafeRandomAccessIterator::Vec((*v).as_mut_ptr().add((*v).len())) {
+        s += (*it.iter_deref());
+        it.iter_inc();
     }
     return s;
 }
diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs
index 7001db4ff..06cdf633c 100644
--- a/tests/unit/out/unsafe/vector.rs
+++ b/tests/unit/out/unsafe/vector.rs
@@ -56,16 +56,25 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((v2.len()) == (3_usize)));
     {
-        let pos = v2.as_mut_ptr().offset_from(v2.as_ptr()) as usize;
+        let pos = <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(
+            v2.as_mut_ptr(),
+        ))
+        .vec_ptr()
+        .offset_from(v2.as_ptr()) as usize;
         v2.remove(pos);
-        v2.as_mut_ptr()
+        <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()))
     };
     assert!(((v2.len()) == (2_usize)));
     assert!(((v2[(0_usize)]) == (2)));
     assert!(((v2[(1_usize)]) == (3)));
     {
-        let pos = v2.as_mut_ptr().offset_from(v2.as_ptr()) as usize;
+        let pos = <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(
+            v2.as_mut_ptr(),
+        ))
+        .vec_ptr()
+        .offset_from(v2.as_ptr()) as usize;
         v2.insert(pos, 100);
+        <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()))
     };
     (unsafe { copy_0(v2.clone()) });
     assert!(((v2.len()) == (3_usize)));
diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs
index 5505d17b1..d568aece8 100644
--- a/tests/unit/out/unsafe/vector_with_allocator.rs
+++ b/tests/unit/out/unsafe/vector_with_allocator.rs
@@ -131,16 +131,25 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((v2.len()) == (3_usize)));
     {
-        let pos = v2.as_mut_ptr().offset_from(v2.as_ptr()) as usize;
+        let pos = <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(
+            v2.as_mut_ptr(),
+        ))
+        .vec_ptr()
+        .offset_from(v2.as_ptr()) as usize;
         v2.remove(pos);
-        v2.as_mut_ptr()
+        <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()))
     };
     assert!(((v2.len()) == (2_usize)));
     assert!(((v2[(0_usize)]) == (2)));
     assert!(((v2[(1_usize)]) == (3)));
     {
-        let pos = v2.as_mut_ptr().offset_from(v2.as_ptr()) as usize;
+        let pos = <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(
+            v2.as_mut_ptr(),
+        ))
+        .vec_ptr()
+        .offset_from(v2.as_ptr()) as usize;
         v2.insert(pos, 100);
+        <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()))
     };
     (unsafe { copy_0(v2.clone()) });
     assert!(((v2.len()) == (3_usize)));
diff --git a/tests/unit/out/unsafe/void_return.rs b/tests/unit/out/unsafe/void_return.rs
index ce31332a0..f224dcedf 100644
--- a/tests/unit/out/unsafe/void_return.rs
+++ b/tests/unit/out/unsafe/void_return.rs
@@ -6,10 +6,38 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn f1_0(mut first: *mut i32, mut last: *mut i32) {
+pub unsafe fn f1_0(
+    mut first: UnsafeRandomAccessIterator<i32>,
+    mut last: UnsafeRandomAccessIterator<i32>,
+) {
     {
-        let len = last.offset_from(first) as usize;
-        ::std::slice::from_raw_parts_mut(first, len).sort()
+        let __n = (last).clone().iter_distance(&(first).clone());
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| {
+            (*(first).clone().iter_at(__x)).cmp(&*(first).clone().iter_at(__y))
+        });
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| std::ptr::read((first).clone().iter_at(__i)))
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write((first).clone().iter_at(__i), __v);
+        }
+    };
+    return;
+}
+pub unsafe fn f1_1(mut first: *mut i32, mut last: *mut i32) {
+    {
+        let __n = last.iter_distance(&first);
+        let mut __order: Vec<isize> = (0..__n).collect();
+        __order.sort_by(|&__x, &__y| (*first.iter_at(__x)).cmp(&*first.iter_at(__y)));
+        let __values: Vec<_> = __order
+            .iter()
+            .map(|&__i| std::ptr::read(first.iter_at(__i)))
+            .collect();
+        for (__i, __v) in (0..__n).zip(__values) {
+            std::ptr::write(first.iter_at(__i), __v);
+        }
     };
     return;
 }
@@ -22,10 +50,18 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut v: Vec<i32> = vec![1, 3, 0, 2, 8, 7];
     (unsafe {
-        let _first: *mut i32 = v.as_mut_ptr();
-        let _last: *mut i32 = v.as_mut_ptr().add(v.len());
+        let _first: UnsafeRandomAccessIterator<i32> =
+            UnsafeRandomAccessIterator::Vec(v.as_mut_ptr());
+        let _last: UnsafeRandomAccessIterator<i32> =
+            UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()));
         f1_0(_first, _last)
     });
+    let mut a: [i32; 3] = [1, 2, 3];
+    (unsafe {
+        let _first: *mut i32 = a.as_mut_ptr();
+        let _last: *mut i32 = a.as_mut_ptr().offset((2) as isize);
+        f1_1(_first, _last)
+    });
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/void_return.cpp b/tests/unit/void_return.cpp
index 6d50e1d23..beb187fe2 100644
--- a/tests/unit/void_return.cpp
+++ b/tests/unit/void_return.cpp
@@ -9,5 +9,8 @@ int main() {
   std::vector<int> v = {1, 3, 0, 2, 8, 7};
   f1(v.begin(), v.end());
 
+  int a[] = {1, 2, 3};
+  f1(a, a + 2);
+
   return 0;
 }