diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 852dde179..2e7eb2248 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -1372,6 +1372,9 @@ bool Converter::VisitDeclStmt(clang::DeclStmt *stmt) {
       hoisted_records_ += std::move(buf).str();
       continue;
     }
+    if (var && IsAliasOfInit(ctx_, var)) {
+      continue;
+    }
     if (var && var->isImplicit()) {
       VisitVarDecl(var);
     } else {
@@ -1487,112 +1490,25 @@ bool Converter::VisitForStmt(clang::ForStmt *stmt) {
   return false;
 }
 
-void Converter::ConvertLoopVariable(clang::VarDecl *decl,
-                                    clang::Expr *range_init) {
-  auto loop_var_type = decl->getType();
-  auto loop_var_name = GetNamedDeclAsString(decl);
-
-  if (loop_var_type->isReferenceType()) {
-    auto pointee_type = loop_var_type->getPointeeType();
-    Convert(range_init);
-    if (pointee_type.isConstQualified()) {
-      StrCat(std::format(".as_ptr().add({})", loop_var_name));
-    } else {
-      StrCat(std::format(".as_mut_ptr().add({})", loop_var_name));
-    }
-  } else {
-    {
-      PushExplicitAutoref autoref(*this, /*is_mut=*/false);
-      Convert(range_init);
-    }
-    StrCat(std::format("[{}]", loop_var_name));
-    StrCat(".clone()");
-  }
-}
-
-void Converter::ConvertForRangeBody(clang::CXXForRangeStmt *stmt) {
-  PushBreakTarget push(break_target_, BreakTarget::Loop);
-  curr_for_inc_.emplace_back(nullptr);
-  ConvertBodyStmts(stmt->getBody());
-  curr_for_inc_.pop_back();
-}
-
 bool Converter::VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) {
-  auto range_init_type = stmt->getRangeInit()->getType();
-
-  if (!Mapper::Contains(ctx_, range_init_type.getUnqualifiedType())) {
-    // FIXME: improve error handling
-    log() << "for range stmts only for types in std namespace\n";
-  }
-
-  log() << "GetClassName: " << GetClassName(range_init_type) << '\n';
-
-  if (GetClassName(range_init_type) == "std::map") {
-    return VisitCXXForRangeStmtMap(stmt);
-  }
-  if (GetClassName(range_init_type) == "std::basic_string") {
-    return VisitCXXForRangeStmtString(stmt);
-  }
-  return VisitCXXForRangeStmtVector(stmt);
-}
-
-bool Converter::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
-  auto begin =
-      llvm::cast<clang::VarDecl>(stmt->getBeginStmt()->getSingleDecl());
-
+  PushBreakTarget push(break_target_, BreakTarget::Loop);
+  Convert(stmt->getInit());
+  Convert(stmt->getRangeStmt());
+  auto *begin =
+      clang::cast<clang::VarDecl>(stmt->getBeginStmt()->getSingleDecl());
+  auto *end = clang::cast<clang::VarDecl>(stmt->getEndStmt()->getSingleDecl());
+  begin->setDeclName(stmt->getLoopVariable()->getDeclName());
   StrCat("'loop_:");
-  auto map_type = Mapper::Map(*this, stmt->getRangeInit()->getType());
   StrCat(keyword::kFor, GetNamedDeclAsString(begin), keyword::kIn,
-         "UnsafeMap::range(&");
-  Convert(stmt->getRangeInit());
-  StrCat(std::format(" as *const {})", map_type));
+         "IterRange::new(", ConvertFreshRValue(begin->getInit()), token::kComma,
+         ConvertFreshRValue(end->getInit()), ')');
   {
     PushBrace brace(*this);
+    curr_for_inc_.emplace_back(nullptr);
     Convert(stmt->getLoopVarStmt());
-    ConvertForRangeBody(stmt);
-  }
-
-  return false;
-}
-
-bool Converter::VisitCXXForRangeStmtString(clang::CXXForRangeStmt *stmt) {
-  return VisitCXXForRangeStmtIndexBased(stmt, "len()-1");
-}
-
-bool Converter::VisitCXXForRangeStmtVector(clang::CXXForRangeStmt *stmt) {
-  return VisitCXXForRangeStmtIndexBased(stmt, "len()");
-}
-
-bool Converter::VisitCXXForRangeStmtIndexBased(clang::CXXForRangeStmt *stmt,
-                                               const char *len_suffix) {
-  auto *loop_var = stmt->getLoopVariable();
-  auto loop_var_name = GetNamedDeclAsString(loop_var);
-
-  StrCat("'loop_:");
-  StrCat(keyword::kFor, loop_var_name, keyword::kIn, "0..");
-  {
-    PushParen range(*this);
-    Convert(stmt->getRangeInit());
-    StrCat(token::kDot, len_suffix);
-  }
-  {
-    PushBrace body(*this);
-    StrCat(keyword::kLet);
-
-    auto loop_var_type = loop_var->getType();
-    if (!loop_var_type.isConstQualified()) {
-      StrCat(keyword_mut_);
-    }
-
-    StrCat(loop_var_name);
-    StrCat(token::kAssign);
-
-    ConvertLoopVariable(loop_var, stmt->getRangeInit());
-
-    StrCat(token::kSemiColon);
-    ConvertForRangeBody(stmt);
+    ConvertBodyStmts(stmt->getBody());
+    curr_for_inc_.pop_back();
   }
-
   return false;
 }
 
@@ -3268,6 +3184,11 @@ bool Converter::VisitDeclRefExpr(clang::DeclRefExpr *expr) {
     Convert(init);
     return false;
   }
+  if (auto var = clang::dyn_cast<clang::VarDecl>(expr->getDecl());
+      var && IsAliasOfInit(ctx_, var)) {
+    Convert(var->getInit());
+    return false;
+  }
   ConvertDeclRefValue(expr, expr->getDecl());
   return false;
 }
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 79022d26e..cd07a0ec8 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -223,17 +223,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt);
 
-  virtual bool VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt);
-
-  virtual bool VisitCXXForRangeStmtVector(clang::CXXForRangeStmt *stmt);
-
-  virtual bool VisitCXXForRangeStmtString(clang::CXXForRangeStmt *stmt);
-
-  bool VisitCXXForRangeStmtIndexBased(clang::CXXForRangeStmt *stmt,
-                                      const char *len_suffix);
-
-  void ConvertForRangeBody(clang::CXXForRangeStmt *stmt);
-
   virtual bool VisitBreakStmt(clang::BreakStmt *stmt);
 
   virtual bool VisitContinueStmt(clang::ContinueStmt *stmt);
@@ -750,9 +739,6 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual void ConvertCast(clang::QualType qual_type,
                            int line = __builtin_LINE());
 
-  virtual void ConvertLoopVariable(clang::VarDecl *decl,
-                                   clang::Expr *range_init);
-
   virtual bool ConvertCXXOperatorCallExpr(clang::CXXOperatorCallExpr *expr);
 
   std::string GetMappedAsString(clang::Expr *expr, clang::Expr **args = nullptr,
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index c516fefe5..b71740ce4 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -1920,10 +1920,10 @@ std::optional<clang::QualType> GetParamImplicitConvertTarget(clang::Expr *expr,
   return fn->getParamDecl(param_idx)->getType().getNonReferenceType();
 }
 
-std::string GetClassName(clang::QualType type) {
-  if (auto *record = type->getAsCXXRecordDecl())
-    return record->getQualifiedNameAsString();
-  return {};
+bool IsAliasOfInit(clang::ASTContext &ctx, const clang::VarDecl *var) {
+  auto *init = var->getInit();
+  return var->isImplicit() && var->getType()->isReferenceType() && init &&
+         init->isGLValue() && !init->HasSideEffects(ctx);
 }
 
 bool IsVaListType(clang::QualType type) {
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index f8511750d..18b02a8b2 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -321,10 +321,10 @@ clang::Expr *BuildInitExpr(clang::Sema &sema, clang::QualType type,
                            llvm::ArrayRef<clang::Expr *> args,
                            clang::SourceLocation loc);
 
-std::string GetClassName(clang::QualType type);
-
 bool IsVaListType(clang::QualType type);
 
+bool IsAliasOfInit(clang::ASTContext &ctx, const clang::VarDecl *var);
+
 bool NeedsImplicitScalarCast(clang::ASTContext &ctx, clang::QualType from,
                              clang::QualType to);
 
diff --git a/cpp2rust/converter/models/boxed_vars.cpp b/cpp2rust/converter/models/boxed_vars.cpp
index e64d6db84..916ad2ccf 100644
--- a/cpp2rust/converter/models/boxed_vars.cpp
+++ b/cpp2rust/converter/models/boxed_vars.cpp
@@ -95,8 +95,17 @@ class AddressTakenVisitor
     : public clang::RecursiveASTVisitor<AddressTakenVisitor> {
 public:
   AddressTakenVisitor(clang::ASTContext &ctx,
-                      std::unordered_set<const clang::VarDecl *> &vars)
-      : ctx_(ctx), address_taken_(vars) {}
+                      std::unordered_set<const clang::VarDecl *> &vars,
+                      std::unordered_set<const clang::VarDecl *> &iterators)
+      : ctx_(ctx), address_taken_(vars), range_iterators_(iterators) {}
+
+  bool VisitCXXForRangeStmt(clang::CXXForRangeStmt *stmt) {
+    if (auto *begin = stmt->getBeginStmt()) {
+      range_iterators_.insert(
+          clang::cast<clang::VarDecl>(begin->getSingleDecl()));
+    }
+    return true;
+  }
 
   bool shouldVisitTemplateInstantiations() const { return true; }
 
@@ -249,18 +258,20 @@ class AddressTakenVisitor
 
   clang::ASTContext &ctx_;
   std::unordered_set<const clang::VarDecl *> &address_taken_;
+  std::unordered_set<const clang::VarDecl *> &range_iterators_;
   // The references to variables that only access their value.
   std::unordered_set<const clang::DeclRefExpr *> value_uses_;
 };
 } // namespace
 
 BoxedVars::BoxedVars(clang::ASTContext &ctx) : ctx_(ctx) {
-  AddressTakenVisitor(ctx, address_taken_)
+  AddressTakenVisitor(ctx, address_taken_, range_iterators_)
       .TraverseDecl(ctx.getTranslationUnitDecl());
 }
 
 bool BoxedVars::contains(const clang::VarDecl *decl) const {
-  return !CanUnbox(ctx_, decl) || address_taken_.contains(decl);
+  return !range_iterators_.contains(decl) &&
+         (!CanUnbox(ctx_, decl) || address_taken_.contains(decl));
 }
 
 namespace {
diff --git a/cpp2rust/converter/models/boxed_vars.h b/cpp2rust/converter/models/boxed_vars.h
index 15e043e9c..d54baef97 100644
--- a/cpp2rust/converter/models/boxed_vars.h
+++ b/cpp2rust/converter/models/boxed_vars.h
@@ -28,6 +28,7 @@ class BoxedVars {
 private:
   clang::ASTContext &ctx_;
   std::unordered_set<const clang::VarDecl *> address_taken_;
+  std::unordered_set<const clang::VarDecl *> range_iterators_;
 };
 
 // The reads of the value of variables in a returned expression that are the
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index a4e1b8acb..9a77c44f4 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -2258,86 +2258,6 @@ bool ConverterRefCount::VisitCXXDeleteExpr(clang::CXXDeleteExpr *expr) {
   return false;
 }
 
-void ConverterRefCount::EmitByValueShadow(const clang::VarDecl *loop_var,
-                                          std::string box_expr,
-                                          const std::string &type_override) {
-  auto type = loop_var->getType();
-  if (!type->isReferenceType()) {
-    bool unboxed = IsUnboxedVar(loop_var);
-    PushConversionKind push(*this, VarConversionKind(loop_var));
-    auto type_str = type_override.empty() ? ToString(type) : type_override;
-    StrCat(keyword::kLet, unboxed ? keyword::kMut : "",
-           GetNamedDeclAsString(loop_var), token::kColon, type_str,
-           token::kAssign);
-    StrCat(BoxValue(std::move(box_expr)), token::kSemiColon);
-  }
-}
-
-bool ConverterRefCount::VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) {
-  auto begin =
-      llvm::cast<clang::VarDecl>(stmt->getBeginStmt()->getSingleDecl());
-  auto begin_name = GetNamedDeclAsString(begin);
-
-  StrCat("'loop_:");
-  StrCat(keyword::kFor, begin_name, keyword::kIn, "Map::range(",
-         ConvertObject(stmt->getRangeInit()), ')');
-  PushBrace brace(*this);
-
-  EmitByValueShadow(begin, std::string(begin_name));
-  Convert(stmt->getLoopVarStmt());
-
-  ConvertForRangeBody(stmt);
-
-  return false;
-}
-
-bool ConverterRefCount::VisitCXXForRangeStmtVector(
-    clang::CXXForRangeStmt *stmt) {
-  auto *loop_var = stmt->getLoopVariable();
-  auto loop_var_name = GetNamedDeclAsString(loop_var);
-
-  StrCat("'loop_:");
-  StrCat(keyword::kFor,
-         stmt->getLoopVariable()->getType().isConstQualified() ? "" : "mut",
-         loop_var_name, keyword::kIn,
-         ConvertObject(stmt->getRangeInit(), ObjectShape::Element));
-  StrCat(keyword::kAs, ConvertPtrType(stmt->getRangeInit()->getType()));
-
-  PushBrace brace(*this);
-
-  auto type = loop_var->getType();
-  bool copy = type.isPODType(ctx_) && !type->isRecordType();
-  EmitByValueShadow(loop_var, loop_var_name + GetPointerDerefSuffix(type) +
-                                  (copy ? "" : ".clone()"));
-
-  ConvertForRangeBody(stmt);
-
-  return false;
-}
-
-bool ConverterRefCount::VisitCXXForRangeStmtString(
-    clang::CXXForRangeStmt *stmt) {
-  auto *loop_var = stmt->getLoopVariable();
-  auto loop_var_name = GetNamedDeclAsString(loop_var);
-
-  StrCat("'loop_:");
-  StrCat(keyword::kFor,
-         stmt->getLoopVariable()->getType().isConstQualified() ? "" : "mut",
-         loop_var_name, keyword::kIn,
-         ConvertObject(stmt->getRangeInit(), ObjectShape::Element));
-  StrCat(".to_string_iterator() as StringIterator<",
-         ToString(loop_var->getType().getNonReferenceType()), '>');
-
-  PushBrace brace(*this);
-
-  EmitByValueShadow(loop_var, loop_var_name +
-                                  GetPointerDerefSuffix(loop_var->getType()) +
-                                  ".clone()");
-  ConvertForRangeBody(stmt);
-
-  return false;
-}
-
 bool ConverterRefCount::VisitArrayInitLoopExpr(clang::ArrayInitLoopExpr *expr) {
   StrCat("Box::new");
   PushParen outer(*this);
diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h
index d4202d185..6ccd80ada 100644
--- a/cpp2rust/converter/models/converter_refcount.h
+++ b/cpp2rust/converter/models/converter_refcount.h
@@ -214,15 +214,6 @@ class ConverterRefCount final : public Converter {
 
   bool VisitCXXDeleteExpr(clang::CXXDeleteExpr *expr) override;
 
-  bool VisitCXXForRangeStmtMap(clang::CXXForRangeStmt *stmt) override;
-
-  bool VisitCXXForRangeStmtVector(clang::CXXForRangeStmt *stmt) override;
-
-  bool VisitCXXForRangeStmtString(clang::CXXForRangeStmt *stmt) override;
-
-  void EmitByValueShadow(const clang::VarDecl *loop_var, std::string box_expr,
-                         const std::string &type_override = "");
-
   std::string ConvertStream(clang::Expr *expr) override;
 
   bool VisitCXXConstructExpr(clang::CXXConstructExpr *expr) override;
diff --git a/docs/src/runtime/iterators.md b/docs/src/runtime/iterators.md
index 7e1861f1a..c1c56feb8 100644
--- a/docs/src/runtime/iterators.md
+++ b/docs/src/runtime/iterators.md
@@ -27,11 +27,8 @@ for x in v.as_pointer() as Ptr<i32> {
 }
 ```
 
-Two variants serve special cases. `StringIterator`, returned by
-`to_string_iterator`, stops before the trailing zero byte, so iterating a
-`std::string` visits its characters only. `PtrValueIter` yields copies of the
-elements instead of pointers to them; rule bodies use it to feed a range of C
-memory to Rust iterator adaptors:
+`PtrValueIter` yields copies of the elements instead of pointers to them; rule
+bodies use it to feed a range of C memory to Rust iterator adaptors:
 
 ```rust
 // std::accumulate(first, last, init)
diff --git a/libcc2rs/src/iterators.rs b/libcc2rs/src/iterators.rs
index 81e42da7e..d7626d0e2 100644
--- a/libcc2rs/src/iterators.rs
+++ b/libcc2rs/src/iterators.rs
@@ -24,27 +24,3 @@ impl<T: CChar> Iterator for CStringIterator<T> {
         Some(ch)
     }
 }
-
-impl<T> Ptr<T> {
-    pub fn to_string_iterator(&self) -> StringIterator<T> {
-        StringIterator { ptr: self.clone() }
-    }
-}
-
-pub struct StringIterator<T> {
-    ptr: Ptr<T>,
-}
-
-impl<T> Iterator for StringIterator<T> {
-    type Item = Ptr<T>;
-    fn next(&mut self) -> Option<Self::Item> {
-        // stop before the null terminator at the last position
-        if self.ptr.get_offset().wrapping_add(1) < self.ptr.len() {
-            let value = self.ptr.clone();
-            self.ptr += 1;
-            Some(value)
-        } else {
-            None
-        }
-    }
-}
diff --git a/rules/iterator_category/shim.rs b/rules/iterator_category/shim.rs
index 3994c5093..bc7832ffa 100644
--- a/rules/iterator_category/shim.rs
+++ b/rules/iterator_category/shim.rs
@@ -451,3 +451,79 @@ random_access_iterator!(
     UnsafeCppRandomAccessIterator,
     std::ptr::null_mut()
 );
+
+pub trait IterStep: Clone + PartialEq {
+    fn iter_step(&mut self);
+}
+
+macro_rules! iter_step {
+    ($name:ty, $iter:ident) => {
+        impl<T> IterStep for $name {
+            fn iter_step(&mut self) {
+                $iter::<T>::iter_inc(self);
+            }
+        }
+    };
+}
+
+iter_step!(Ptr<T>, CppIterator);
+iter_step!(*mut T, UnsafeCppIterator);
+iter_step!(*const T, UnsafeCppIterator);
+iter_step!(InputIterator<T>, CppIterator);
+iter_step!(ForwardIterator<T>, CppIterator);
+iter_step!(UnsafeInputIterator<T>, UnsafeCppIterator);
+iter_step!(UnsafeForwardIterator<T>, UnsafeCppIterator);
+iter_step!(BidirectionalIterator<T>, CppIterator);
+iter_step!(UnsafeBidirectionalIterator<T>, UnsafeCppIterator);
+iter_step!(RandomAccessIterator<T>, CppIterator);
+iter_step!(UnsafeRandomAccessIterator<T>, UnsafeCppIterator);
+
+pub struct IterRange<I> {
+    cur: I,
+    end: I,
+}
+
+impl<I: IterStep> IterRange<I> {
+    pub fn new(cur: I, end: I) -> Self {
+        Self { cur, end }
+    }
+}
+
+impl<I: IterStep> Iterator for IterRange<I> {
+    type Item = I;
+
+    fn next(&mut self) -> Option<I> {
+        if self.cur == self.end {
+            return None;
+        }
+        let it = self.cur.clone();
+        self.cur.iter_step();
+        Some(it)
+    }
+}
+
+pub trait CppRange {
+    type Iter;
+    fn begin(&self) -> Self::Iter;
+    fn end(&self) -> Self::Iter;
+}
+
+impl<T> CppRange for Vec<T> {
+    type Iter = UnsafeRandomAccessIterator<T>;
+    fn begin(&self) -> Self::Iter {
+        UnsafeRandomAccessIterator::Vec(self.as_ptr().cast_mut())
+    }
+    fn end(&self) -> Self::Iter {
+        UnsafeRandomAccessIterator::Vec(self.as_ptr().wrapping_add(self.len()).cast_mut())
+    }
+}
+
+impl<T> CppRange for Ptr<T> {
+    type Iter = RandomAccessIterator<T>;
+    fn begin(&self) -> Self::Iter {
+        RandomAccessIterator::Vec(self.clone())
+    }
+    fn end(&self) -> Self::Iter {
+        RandomAccessIterator::Vec(self.to_end())
+    }
+}
diff --git a/rules/map/src.cpp b/rules/map/src.cpp
index 8bf47b3b1..4177680d8 100644
--- a/rules/map/src.cpp
+++ b/rules/map/src.cpp
@@ -98,3 +98,8 @@ std::size_t f28(std::map<T1, T2> &o,
                 const typename std::map<T1, T2>::key_type &key) {
   return o.erase(key);
 }
+
+template <typename T1, typename T2>
+typename std::map<T1, T2>::const_iterator f29(const std::map<T1, T2> &o) {
+  return o.begin();
+}
diff --git a/rules/map/tgt_refcount.rs b/rules/map/tgt_refcount.rs
index 06c92082f..394ae6edf 100644
--- a/rules/map/tgt_refcount.rs
+++ b/rules/map/tgt_refcount.rs
@@ -113,3 +113,7 @@ fn f27<T1: Ord + Clone + 'static, T2: 'static>(
 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))
 }
+
+fn f29<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())
+}
diff --git a/rules/map/tgt_unsafe.rs b/rules/map/tgt_unsafe.rs
index 073c0cc63..50440d791 100644
--- a/rules/map/tgt_unsafe.rs
+++ b/rules/map/tgt_unsafe.rs
@@ -85,3 +85,7 @@ unsafe fn f27<T1: Ord + Clone, T2>(
 unsafe fn f28<T1: Ord, T2>(a0: &mut UnsafeMap<T1, (T1, T2)>, a1: T1) -> usize {
     a0.erase_key(&a1)
 }
+
+unsafe fn f29<T1, T2>(a0: UnsafeMap<T1, (T1, T2)>) -> UnsafeBidirectionalIterator<(T1, T2)> {
+    a0.begin()
+}
diff --git a/rules/vector/tgt_refcount.rs b/rules/vector/tgt_refcount.rs
index e4f1077f6..111566a2a 100644
--- a/rules/vector/tgt_refcount.rs
+++ b/rules/vector/tgt_refcount.rs
@@ -32,11 +32,11 @@ fn f69<T1>(a0: Ptr<T1>) -> Ptr<T1> {
 }
 
 fn f72<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
-    RandomAccessIterator::Vec(a0)
+    a0.begin()
 }
 
 fn f76<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
-    RandomAccessIterator::Vec(a0.to_end())
+    a0.end()
 }
 
 fn f77<T1: ByteRepr>(a0: &mut Vec<T1>, a1: RandomAccessIterator<T1>, a2: T1) -> RandomAccessIterator<T1> {
@@ -68,11 +68,11 @@ fn f93<T1>(a0: Ptr<T1>) -> Ptr<T1> {
 }
 
 fn f95<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
-    RandomAccessIterator::Vec(a0)
+    a0.begin()
 }
 
 fn f96<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
-    RandomAccessIterator::Vec(a0.to_end())
+    a0.end()
 }
 
 fn f98<T1: ByteRepr>(a0: Ptr<Vec<T1>>, a1: usize) -> Ptr<Vec<T1>> {
@@ -107,7 +107,7 @@ fn f103<T1: ByteRepr + Clone>(a0: Ptr<Vec<T1>>, a1: &mut Vec<T1>) {
 }
 
 fn f104<T1>(a0: Ptr<T1>) -> RandomAccessIterator<T1> {
-    RandomAccessIterator::Vec(a0.to_end())
+    a0.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 d8c5fa4b2..ffcb4fccd 100644
--- a/rules/vector/tgt_unsafe.rs
+++ b/rules/vector/tgt_unsafe.rs
@@ -79,7 +79,7 @@ unsafe fn f71<T1>(a0: &mut Vec<T1>, a1: usize) {
 }
 
 unsafe fn f72<T1>(a0: &mut Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
-    UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr())
+    a0.begin()
 }
 
 unsafe fn f73<T1: Default>(a0: &mut Vec<T1>, a1: &mut T1) {
@@ -97,7 +97,7 @@ unsafe fn f75<T1>(a0: &mut Vec<T1>) {
 }
 
 unsafe fn f76<T1>(a0: &mut Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
-    UnsafeRandomAccessIterator::Vec(a0.as_mut_ptr().add(a0.len()))
+    a0.end()
 }
 
 unsafe fn f77<T1>(a0: &mut Vec<T1>, a1: UnsafeRandomAccessIterator<T1>, a2: T1) -> UnsafeRandomAccessIterator<T1> {
@@ -141,11 +141,11 @@ unsafe fn f93<T1>(a0: &mut Vec<T1>) -> *const T1 {
 }
 
 unsafe fn f95<T1>(a0: Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
-    UnsafeRandomAccessIterator::Vec(a0.as_ptr().cast_mut())
+    a0.begin()
 }
 
 unsafe fn f96<T1>(a0: Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
-    UnsafeRandomAccessIterator::Vec(a0.as_ptr().add(a0.len()).cast_mut())
+    a0.end()
 }
 
 unsafe fn f97(a0: &mut Vec<bool>, a1: &mut Vec<bool>) {
@@ -189,7 +189,7 @@ unsafe fn f103<T1: Clone>(a0: &mut Vec<T1>, a1: &mut Vec<T1>) {
 }
 
 unsafe fn f104<T1>(a0: Vec<T1>) -> UnsafeRandomAccessIterator<T1> {
-    UnsafeRandomAccessIterator::Vec(a0.as_ptr().add(a0.len()).cast_mut())
+    a0.end()
 }
 
 unsafe fn f105<T1: Clone>(a0: &mut Vec<T1>, a1: Vec<T1>) {
diff --git a/tests/unit/out/refcount/auto.rs b/tests/unit/out/refcount/auto.rs
index 100c41315..7dfe2c935 100644
--- a/tests/unit/out/refcount/auto.rs
+++ b/tests/unit/out/refcount/auto.rs
@@ -24,8 +24,11 @@ fn main_0() -> i32 {
         (*v.borrow_mut()).push(__a1)
     };
     let mut sum: i32 = 0;
-    'loop_: for mut elem in v.as_pointer() as Ptr<i32> {
-        let mut elem: i32 = elem.read();
+    'loop_: for elem in IterRange::new(
+        (v.as_pointer() as Ptr<i32>).begin(),
+        (v.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let mut elem: i32 = (elem.iter_deref().read());
         sum += elem;
     }
     assert!((sum == 3));
diff --git a/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs b/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs
index 9a7ae4e17..ae79c0e9e 100644
--- a/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs
+++ b/tests/unit/out/refcount/elidable_iterator_copy_cxx11.rs
@@ -21,55 +21,52 @@ fn main_0() -> i32 {
         (*v.borrow_mut()).push(__a1)
     };
     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)
+        let mut __it = (v.as_pointer() as Ptr<i32>).begin();
+        while __it != (v.as_pointer() as Ptr<i32>).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()) != (v.as_pointer() as Ptr<i32>).end());
     assert!((((*it.borrow()).iter_deref().read()) == 7));
     {
-        let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end())
-            .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)));
+        let __n = (v.as_pointer() as Ptr<i32>)
+            .end()
+            .iter_distance(&(v.as_pointer() as Ptr<i32>).begin());
         let __random = std::hash::RandomState::new();
         for __i in (1..__n).rev() {
             let __j =
                 (std::hash::BuildHasher::hash_one(&__random, __i) % (__i + 1) as u64) as isize;
-            let __x = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)).iter_at(__i);
-            let __y = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)).iter_at(__j);
+            let __x = (v.as_pointer() as Ptr<i32>).begin().iter_at(__i);
+            let __y = (v.as_pointer() as Ptr<i32>).begin().iter_at(__j);
             let __tmp = __x.read();
             __x.write(__y.read());
             __y.write(__tmp);
         }
     };
     {
-        let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end())
-            .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)));
+        let __n = (v.as_pointer() as Ptr<i32>)
+            .end()
+            .iter_distance(&(v.as_pointer() as Ptr<i32>).begin());
         let mut __order: Vec<isize> = (0..__n).collect();
         __order.sort_by(|&__x, &__y| {
-            RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+            (v.as_pointer() as Ptr<i32>)
+                .begin()
                 .iter_at(__x)
                 .with(|__a| {
-                    RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+                    (v.as_pointer() as Ptr<i32>)
+                        .begin()
                         .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()
-            })
+            .map(|&__i| (v.as_pointer() as Ptr<i32>).begin().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);
+            (v.as_pointer() as Ptr<i32>).begin().iter_at(__i).write(__v);
         }
     };
     assert!(({ (*v.borrow())[0_usize] } == 4) && ({ (*v.borrow())[1_usize] } == 7));
diff --git a/tests/unit/out/refcount/find.rs b/tests/unit/out/refcount/find.rs
index bd60dc9bb..314c02895 100644
--- a/tests/unit/out/refcount/find.rs
+++ b/tests/unit/out/refcount/find.rs
@@ -24,12 +24,10 @@ fn main_0() -> i32 {
         let __a1 = 3;
         (*v.borrow_mut()).push(__a1)
     };
-    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 v_begin: Value<RandomAccessIterator<i32>> =
+        Rc::new(RefCell::new((v.as_pointer() as Ptr<i32>).begin()));
+    let v_end: Value<RandomAccessIterator<i32>> =
+        Rc::new(RefCell::new((v.as_pointer() as Ptr<i32>).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) {
@@ -37,8 +35,7 @@ fn main_0() -> i32 {
         }
         __it
     }));
-    let mut v_result_true: bool =
-        (*it.borrow()) != RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end());
+    let mut v_result_true: bool = (*it.borrow()) != (v.as_pointer() as Ptr<i32>).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>)>| {
@@ -91,51 +88,48 @@ fn main_0() -> i32 {
     assert!(
         ((v_result_true) && (m_result_true))
             && ({
-                let mut __it = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>));
-                while __it != RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+                let mut __it = (v.as_pointer() as Ptr<i32>).begin();
+                while __it != (v.as_pointer() as Ptr<i32>).begin()
                     && __it.iter_deref().with(|__v| *__v != 2)
                 {
                     __it.iter_inc();
                 }
                 __it
-            } == RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)))
+            } == (v.as_pointer() as Ptr<i32>).begin())
     );
     let w: Value<Vec<i32>> = Rc::new(RefCell::new(Vec::from([1, 2, 3, 4, 5])));
     assert!(
         {
-            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())
+            let mut __it = (w.as_pointer() as Ptr<i32>).begin().iter_add(2_isize);
+            while __it != (w.as_pointer() as Ptr<i32>).end()
                 && __it.iter_deref().with(|__v| *__v != 4)
             {
                 __it.iter_inc();
             }
             __it
-        } == RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>)).iter_add(3_isize)
+        } == (w.as_pointer() as Ptr<i32>).begin().iter_add(3_isize)
     );
     assert!(
         {
-            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())
+            let mut __it = (w.as_pointer() as Ptr<i32>).begin().iter_add(2_isize);
+            while __it != (w.as_pointer() as Ptr<i32>).end()
                 && __it.iter_deref().with(|__v| *__v != 1)
             {
                 __it.iter_inc();
             }
             __it
-        } == RandomAccessIterator::Vec((w.as_pointer() as Ptr<i32>).to_end())
+        } == (w.as_pointer() as Ptr<i32>).end()
     );
     assert!(
         {
-            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)
+            let mut __it = (w.as_pointer() as Ptr<i32>).begin().iter_add(2_isize);
+            while __it != (w.as_pointer() as Ptr<i32>).begin().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)
+        } == (w.as_pointer() as Ptr<i32>).begin().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 6e40e5a33..377b0f76d 100644
--- a/tests/unit/out/refcount/fn_ptr_stable_sort.rs
+++ b/tests/unit/out/refcount/fn_ptr_stable_sort.rs
@@ -36,12 +36,13 @@ fn main_0() -> i32 {
         (*v.borrow_mut()).push(__a1)
     };
     {
-        let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>).to_end())
-            .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>)));
+        let __n = (v.as_pointer() as Ptr<Item>)
+            .end()
+            .iter_distance(&(v.as_pointer() as Ptr<Item>).begin());
         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);
+            let __a = (v.as_pointer() as Ptr<Item>).begin().iter_at(__x);
+            let __b = (v.as_pointer() as Ptr<Item>).begin().iter_at(__y);
             if Compare_0.call(__a.clone(), __b.clone()) {
                 std::cmp::Ordering::Less
             } else if Compare_0.call(__b, __a) {
@@ -52,14 +53,11 @@ fn main_0() -> i32 {
         });
         let __values: Vec<_> = __order
             .iter()
-            .map(|&__i| {
-                RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>))
-                    .iter_at(__i)
-                    .read()
-            })
+            .map(|&__i| (v.as_pointer() as Ptr<Item>).begin().iter_at(__i).read())
             .collect();
         for (__i, __v) in (0..__n).zip(__values) {
-            RandomAccessIterator::Vec((v.as_pointer() as Ptr<Item>))
+            (v.as_pointer() as Ptr<Item>)
+                .begin()
                 .iter_at(__i)
                 .write(__v);
         }
diff --git a/tests/unit/out/refcount/foreach.rs b/tests/unit/out/refcount/foreach.rs
index 676cbe3ad..06fc3977f 100644
--- a/tests/unit/out/refcount/foreach.rs
+++ b/tests/unit/out/refcount/foreach.rs
@@ -21,8 +21,11 @@ fn main_0() -> i32 {
         i.prefix_inc();
     }
     let mut sum: i32 = 0;
-    'loop_: for mut x in v.as_pointer() as Ptr<i32> {
-        let mut x: i32 = x.read();
+    'loop_: for x in IterRange::new(
+        (v.as_pointer() as Ptr<i32>).begin(),
+        (v.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let mut x: i32 = (x.iter_deref().read());
         sum += x;
     }
     assert!((sum == 45));
diff --git a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
index c6ecdf2c7..7d7a1c25f 100644
--- a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
+++ b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
@@ -25,8 +25,11 @@ fn main_0() -> i32 {
         let __a1 = 1;
         (*s.borrow_mut()).v.push(__a1)
     };
-    'loop_: for mut e in field_ref!(s.as_pointer(), v).as_pointer() as Ptr<i32> {
-        let mut e: i32 = e.read();
+    'loop_: for e in IterRange::new(
+        (field_ref!(s.as_pointer(), v).as_pointer() as Ptr<i32>).begin(),
+        (field_ref!(s.as_pointer(), v).as_pointer() as Ptr<i32>).end(),
+    ) {
+        let mut e: i32 = (e.iter_deref().read());
         (*s.borrow_mut()).a.postfix_inc();
     }
     return 0;
diff --git a/tests/unit/out/refcount/foreach_double.rs b/tests/unit/out/refcount/foreach_double.rs
index 293f327e3..b4122174c 100644
--- a/tests/unit/out/refcount/foreach_double.rs
+++ b/tests/unit/out/refcount/foreach_double.rs
@@ -25,25 +25,55 @@ fn main_0() -> i32 {
         (*v.borrow_mut()).push(__a1)
     };
     let mut square: i32 = 0;
-    'loop_: for mut e1 in v.as_pointer() as Ptr<i32> {
-        let mut e1: i32 = e1.read();
-        'loop_: for mut e2 in v.as_pointer() as Ptr<i32> {
-            let mut e2: i32 = e2.read();
+    'loop_: for e1 in IterRange::new(
+        (v.as_pointer() as Ptr<i32>).begin(),
+        (v.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let mut e1: i32 = (e1.iter_deref().read());
+        'loop_: for e2 in IterRange::new(
+            (v.as_pointer() as Ptr<i32>).begin(),
+            (v.as_pointer() as Ptr<i32>).end(),
+        ) {
+            let mut e2: i32 = (e2.iter_deref().read());
             square += (e1 * e2);
         }
     }
-    'loop_: for mut e1 in v.as_pointer() as Ptr<i32> {
-        'loop_: for mut e2 in v.as_pointer() as Ptr<i32> {
+    'loop_: for e1 in IterRange::new(
+        (v.as_pointer() as Ptr<i32>).begin(),
+        (v.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let e1: Ptr<i32> = e1.iter_deref();
+        'loop_: for e2 in IterRange::new(
+            (v.as_pointer() as Ptr<i32>).begin(),
+            (v.as_pointer() as Ptr<i32>).end(),
+        ) {
+            let e2: Ptr<i32> = e2.iter_deref();
             square += { ({ (e1.read()) } * { (e2.read()) }) };
         }
     }
-    'loop_: for mut e1 in v.as_pointer() as Ptr<i32> {
-        'loop_: for mut e2 in v.as_pointer() as Ptr<i32> {
+    'loop_: for e1 in IterRange::new(
+        (v.as_pointer() as Ptr<i32>).begin(),
+        (v.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let e1: Ptr<i32> = e1.iter_deref();
+        'loop_: for e2 in IterRange::new(
+            (v.as_pointer() as Ptr<i32>).begin(),
+            (v.as_pointer() as Ptr<i32>).end(),
+        ) {
+            let e2: Ptr<i32> = e2.iter_deref();
             square += { ({ (e1.read()) } * { (e2.read()) }) };
         }
     }
-    'loop_: for mut e1 in v.as_pointer() as Ptr<i32> {
-        'loop_: for mut e2 in v.as_pointer() as Ptr<i32> {
+    'loop_: for e1 in IterRange::new(
+        (v.as_pointer() as Ptr<i32>).begin(),
+        (v.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let e1: Ptr<i32> = e1.iter_deref();
+        'loop_: for e2 in IterRange::new(
+            (v.as_pointer() as Ptr<i32>).begin(),
+            (v.as_pointer() as Ptr<i32>).end(),
+        ) {
+            let e2: Ptr<i32> = e2.iter_deref();
             square += { ({ (e1.read()) } * { (e2.read()) }) };
         }
     }
@@ -63,8 +93,16 @@ fn main_0() -> i32 {
         let __a1 = std::mem::take(&mut (*v3.borrow_mut()));
         (*m.borrow_mut()).push(__a1)
     };
-    'loop_: for mut row in m.as_pointer() as Ptr<Vec<i32>> {
-        'loop_: for mut col in Ptr::<Vec<i32>>::decay(&(row)) as Ptr<i32> {
+    'loop_: for row in IterRange::new(
+        (m.as_pointer() as Ptr<Vec<i32>>).begin(),
+        (m.as_pointer() as Ptr<Vec<i32>>).end(),
+    ) {
+        let row: Ptr<Vec<i32>> = row.iter_deref();
+        'loop_: for col in IterRange::new(
+            (Ptr::<Vec<i32>>::decay(&(row)) as Ptr<i32>).begin(),
+            (Ptr::<Vec<i32>>::decay(&(row)) as Ptr<i32>).end(),
+        ) {
+            let col: Ptr<i32> = col.iter_deref();
             square += { (col.read()) };
         }
     }
diff --git a/tests/unit/out/refcount/foreach_map.rs b/tests/unit/out/refcount/foreach_map.rs
index 6ded20983..f5a23ac6c 100644
--- a/tests/unit/out/refcount/foreach_map.rs
+++ b/tests/unit/out/refcount/foreach_map.rs
@@ -34,56 +34,56 @@ fn main_0() -> i32 {
         };
     }
     let mut sum: f64 = 0_f64;
-    '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();
+    'loop_: for i in IterRange::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.begin()),
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.end()),
+    ) {
+        let i: Ptr<(Value<i32>, Value<f64>)> = i.iter_deref();
         sum += (*(*i.upgrade().deref()).1.borrow());
     }
-    'loop_: for __begin1 in Map::range(m.as_pointer()) {
-        let __begin1: Value<BidirectionalIterator<(Value<i32>, Value<f64>)>> =
-            Rc::new(RefCell::new(__begin1));
+    'loop_: for i in IterRange::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.begin()),
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.end()),
+    ) {
         let i: Value<(Value<i32>, Value<f64>)> = Rc::new(RefCell::new((
             Rc::new(RefCell::new(
-                (*(*__begin1.borrow()).iter_deref().upgrade().deref())
-                    .0
-                    .borrow()
-                    .clone(),
+                (*i.iter_deref().upgrade().deref()).0.borrow().clone(),
             )),
             Rc::new(RefCell::new(
-                (*(*__begin1.borrow()).iter_deref().upgrade().deref())
-                    .1
-                    .borrow()
-                    .clone(),
+                (*i.iter_deref().upgrade().deref()).1.borrow().clone(),
             )),
         )));
         sum += ((*(*i.borrow()).0.borrow()) as f64);
     }
     assert!((sum == 7475_f64));
-    'loop_: for __begin1 in Map::range(m.as_pointer()) {
-        let __begin1: Value<BidirectionalIterator<(Value<i32>, Value<f64>)>> =
-            Rc::new(RefCell::new(__begin1));
+    'loop_: for i in IterRange::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.begin()),
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.end()),
+    ) {
         let i: Value<(Value<i32>, Value<f64>)> = Rc::new(RefCell::new((
             Rc::new(RefCell::new(
-                (*(*__begin1.borrow()).iter_deref().upgrade().deref())
-                    .0
-                    .borrow()
-                    .clone(),
+                (*i.iter_deref().upgrade().deref()).0.borrow().clone(),
             )),
             Rc::new(RefCell::new(
-                (*(*__begin1.borrow()).iter_deref().upgrade().deref())
-                    .1
-                    .borrow()
-                    .clone(),
+                (*i.iter_deref().upgrade().deref()).1.borrow().clone(),
             )),
         )));
         (*(*i.borrow()).1.borrow_mut()) = (-1_i32 as f64);
         assert!(((*(*i.borrow()).1.borrow()) == (-1_i32 as f64)));
     }
-    'loop_: for __begin1 in 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();
+    'loop_: for i in IterRange::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.begin()),
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<f64>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<f64>)>| __m.end()),
+    ) {
+        let i: Ptr<(Value<i32>, Value<f64>)> = i.iter_deref();
         assert!(((*(*i.upgrade().deref()).1.borrow()) != (-1_i32 as f64)));
     }
     return 0;
diff --git a/tests/unit/out/refcount/foreach_mut.rs b/tests/unit/out/refcount/foreach_mut.rs
index 4828b9078..92f66396b 100644
--- a/tests/unit/out/refcount/foreach_mut.rs
+++ b/tests/unit/out/refcount/foreach_mut.rs
@@ -25,20 +25,34 @@ fn main_0() -> i32 {
         (*v1.borrow_mut()).push(__a1)
     };
     let mut sum: i32 = 0;
-    'loop_: for mut x in v1.as_pointer() as Ptr<i32> {
-        let mut x: i32 = x.read();
+    'loop_: for x in IterRange::new(
+        (v1.as_pointer() as Ptr<i32>).begin(),
+        (v1.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let mut x: i32 = (x.iter_deref().read());
         sum += x.prefix_inc();
     }
-    'loop_: for x in v1.as_pointer() as Ptr<i32> {
-        let mut x: i32 = x.read();
+    'loop_: for x in IterRange::new(
+        (v1.as_pointer() as Ptr<i32>).begin(),
+        (v1.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let mut x: i32 = (x.iter_deref().read());
         sum += x;
     }
-    'loop_: for mut x in v1.as_pointer() as Ptr<i32> {
+    'loop_: for x in IterRange::new(
+        (v1.as_pointer() as Ptr<i32>).begin(),
+        (v1.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let x: Ptr<i32> = x.iter_deref();
         {
             x.with_mut(|__v| *__v = *__v + 10)
         };
     }
-    'loop_: for mut x in v1.as_pointer() as Ptr<i32> {
+    'loop_: for x in IterRange::new(
+        (v1.as_pointer() as Ptr<i32>).begin(),
+        (v1.as_pointer() as Ptr<i32>).end(),
+    ) {
+        let x: Ptr<i32> = x.iter_deref();
         sum += { (x.read()) };
     }
     let v2: Value<Vec<Ptr<i32>>> = Rc::new(RefCell::new(Vec::new()));
@@ -54,24 +68,36 @@ fn main_0() -> i32 {
         let __a1 = ((v1.as_pointer() as Ptr<i32>).offset(2_usize));
         (*v2.borrow_mut()).push(__a1)
     };
-    'loop_: for mut p in v2.as_pointer() as Ptr<Ptr<i32>> {
-        let mut p: Ptr<i32> = p.read();
+    'loop_: for p in IterRange::new(
+        (v2.as_pointer() as Ptr<Ptr<i32>>).begin(),
+        (v2.as_pointer() as Ptr<Ptr<i32>>).end(),
+    ) {
+        let mut p: Ptr<i32> = (p.iter_deref().read());
         {
             p.with_mut(|__v| *__v = *__v + 5)
         };
     }
-    'loop_: for p in v2.as_pointer() as Ptr<Ptr<i32>> {
-        let mut p: Ptr<i32> = p.read();
+    'loop_: for p in IterRange::new(
+        (v2.as_pointer() as Ptr<Ptr<i32>>).begin(),
+        (v2.as_pointer() as Ptr<Ptr<i32>>).end(),
+    ) {
+        let mut p: Ptr<i32> = (p.iter_deref().read());
         sum += { (p.read()) };
     }
-    'loop_: for mut p in v2.as_pointer() as Ptr<Ptr<i32>> {
-        let mut p: Ptr<i32> = p.read();
+    'loop_: for p in IterRange::new(
+        (v2.as_pointer() as Ptr<Ptr<i32>>).begin(),
+        (v2.as_pointer() as Ptr<Ptr<i32>>).end(),
+    ) {
+        let mut p: Ptr<i32> = (p.iter_deref().read());
         {
             p.with_mut(|__v| *__v = *__v + 5)
         };
     }
-    'loop_: for mut p in v2.as_pointer() as Ptr<Ptr<i32>> {
-        let mut p: Ptr<i32> = p.read();
+    'loop_: for p in IterRange::new(
+        (v2.as_pointer() as Ptr<Ptr<i32>>).begin(),
+        (v2.as_pointer() as Ptr<Ptr<i32>>).end(),
+    ) {
+        let mut p: Ptr<i32> = (p.iter_deref().read());
         sum += { (p.read()) };
     }
     assert!((sum == 168));
diff --git a/tests/unit/out/refcount/iterator_freshness.rs b/tests/unit/out/refcount/iterator_freshness.rs
index 48f08d0bf..f84b4b162 100644
--- a/tests/unit/out/refcount/iterator_freshness.rs
+++ b/tests/unit/out/refcount/iterator_freshness.rs
@@ -19,9 +19,8 @@ fn main_0() -> i32 {
             .map(|_| <i32>::default())
             .collect::<Vec<_>>(),
     ));
-    let it: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(RandomAccessIterator::Vec(
-        (vec_.as_pointer() as Ptr<i32>),
-    )));
+    let it: Value<RandomAccessIterator<i32>> =
+        Rc::new(RefCell::new((vec_.as_pointer() as Ptr<i32>).begin()));
     ({ foo_0((*it.borrow()).clone()) });
     return 0;
 }
diff --git a/tests/unit/out/refcount/iterators.rs b/tests/unit/out/refcount/iterators.rs
index 5bd79f7a9..899364dd6 100644
--- a/tests/unit/out/refcount/iterators.rs
+++ b/tests/unit/out/refcount/iterators.rs
@@ -16,14 +16,25 @@ fn main_0() -> i32 {
         __bytes.push(0);
         __bytes
     }));
-    'loop_: for mut c in x.as_pointer().to_string_iterator() as StringIterator<i8> {
+    'loop_: for c in IterRange::new(
+        (x.as_pointer() as Ptr<i8>),
+        (x.as_pointer() as Ptr<i8>).to_last(),
+    ) {
+        let c: Ptr<i8> = c.iter_deref();
         c.with_mut(|__v| __v.prefix_inc());
     }
-    'loop_: for mut c in x.as_pointer().to_string_iterator() as StringIterator<i8> {
+    'loop_: for c in IterRange::new(
+        (x.as_pointer() as Ptr<i8>),
+        (x.as_pointer() as Ptr<i8>).to_last(),
+    ) {
+        let c: Ptr<i8> = c.iter_deref();
         println!("{}", ((c.read()) as i32) as u8 as char);
     }
-    'loop_: for mut c in x.as_pointer().to_string_iterator() as StringIterator<i8> {
-        let mut c: i8 = c.read().clone();
+    'loop_: for c in IterRange::new(
+        (x.as_pointer() as Ptr<i8>),
+        (x.as_pointer() as Ptr<i8>).to_last(),
+    ) {
+        let mut c: i8 = (c.iter_deref().read());
         println!("{}", (c as i32) as u8 as char);
     }
     let v: Value<Vec<Ptr<i32>>> = Rc::new(RefCell::new(Vec::new()));
@@ -35,8 +46,11 @@ fn main_0() -> i32 {
         let __a1 = Ptr::alloc(3);
         (*v.borrow_mut()).push(__a1)
     };
-    'loop_: for mut p in v.as_pointer() as Ptr<Ptr<i32>> {
-        let mut p: Ptr<i32> = p.read();
+    'loop_: for p in IterRange::new(
+        (v.as_pointer() as Ptr<Ptr<i32>>).begin(),
+        (v.as_pointer() as Ptr<Ptr<i32>>).end(),
+    ) {
+        let mut p: Ptr<i32> = (p.iter_deref().read());
         println!("{}", (p.read()));
     }
     return 0;
diff --git a/tests/unit/out/refcount/map-reallocation.rs b/tests/unit/out/refcount/map-reallocation.rs
index 114d64aab..5f407c2bd 100644
--- a/tests/unit/out/refcount/map-reallocation.rs
+++ b/tests/unit/out/refcount/map-reallocation.rs
@@ -128,10 +128,13 @@ 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 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();
+    'loop_: for pair in IterRange::new(
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.begin()),
+        (m.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<i32>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<i32>)>| __m.end()),
+    ) {
+        let pair: Ptr<(Value<i32>, Value<i32>)> = pair.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 101862155..490a32f41 100644
--- a/tests/unit/out/refcount/map.rs
+++ b/tests/unit/out/refcount/map.rs
@@ -667,10 +667,13 @@ fn main_0() -> i32 {
     }
     assert!(((*m2.borrow()).len() == indexes.len()));
     let mut last: i32 = -1_i32;
-    '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();
+    'loop_: for pair in IterRange::new(
+        (m2.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<bool>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<bool>)>| __m.begin()),
+        (m2.as_pointer() as Ptr<Map<i32, (Value<i32>, Value<bool>)>>)
+            .with(|__m: &Map<i32, (Value<i32>, Value<bool>)>| __m.end()),
+    ) {
+        let pair: Ptr<(Value<i32>, Value<bool>)> = pair.iter_deref();
         assert!(({ (*(*pair.upgrade().deref()).0.borrow()) } > { last }));
         assert!(
             ({ ((*(*pair.upgrade().deref()).1.borrow()) as i32) } == {
diff --git a/tests/unit/out/refcount/map_key_identity.rs b/tests/unit/out/refcount/map_key_identity.rs
index e48c038e3..d6c75770b 100644
--- a/tests/unit/out/refcount/map_key_identity.rs
+++ b/tests/unit/out/refcount/map_key_identity.rs
@@ -229,10 +229,13 @@ fn main_0() -> i32 {
         ok = rhs_0
     };
     let mut distinct_count: usize = 0_usize;
-    'loop_: for __begin1 in Map::range(distinct.as_pointer()) {
-        let __begin1: Value<BidirectionalIterator<(Value<Key>, Value<Mapped>)>> =
-            Rc::new(RefCell::new(__begin1));
-        let entry: Ptr<(Value<Key>, Value<Mapped>)> = (*__begin1.borrow()).iter_deref();
+    'loop_: for entry in IterRange::new(
+        (distinct.as_pointer() as Ptr<Map<Key, (Value<Key>, Value<Mapped>)>>)
+            .with(|__m: &Map<Key, (Value<Key>, Value<Mapped>)>| __m.begin()),
+        (distinct.as_pointer() as Ptr<Map<Key, (Value<Key>, Value<Mapped>)>>)
+            .with(|__m: &Map<Key, (Value<Key>, Value<Mapped>)>| __m.end()),
+    ) {
+        let entry: Ptr<(Value<Key>, Value<Mapped>)> = entry.iter_deref();
         if (distinct_count == 0_usize) {
             ok = {
                 ((ok as i32)
@@ -373,10 +376,13 @@ fn main_0() -> i32 {
             ok = rhs_0
         };
         let mut equivalent_count: usize = 0_usize;
-        'loop_: for __begin2 in Map::range(equivalent.as_pointer()) {
-            let __begin2: Value<BidirectionalIterator<(Value<Key>, Value<Mapped>)>> =
-                Rc::new(RefCell::new(__begin2));
-            let entry: Ptr<(Value<Key>, Value<Mapped>)> = (*__begin2.borrow()).iter_deref();
+        'loop_: for entry in IterRange::new(
+            (equivalent.as_pointer() as Ptr<Map<Key, (Value<Key>, Value<Mapped>)>>)
+                .with(|__m: &Map<Key, (Value<Key>, Value<Mapped>)>| __m.begin()),
+            (equivalent.as_pointer() as Ptr<Map<Key, (Value<Key>, Value<Mapped>)>>)
+                .with(|__m: &Map<Key, (Value<Key>, Value<Mapped>)>| __m.end()),
+        ) {
+            let entry: Ptr<(Value<Key>, Value<Mapped>)> = entry.iter_deref();
             ok = {
                 ((ok as i32)
                     & ((({ (*(*entry.upgrade().deref()).0.borrow()).order } == 3)
diff --git a/tests/unit/out/refcount/operator_traits.rs b/tests/unit/out/refcount/operator_traits.rs
index 9515ba0dc..1c69bd9c9 100644
--- a/tests/unit/out/refcount/operator_traits.rs
+++ b/tests/unit/out/refcount/operator_traits.rs
@@ -165,28 +165,28 @@ fn main_0() -> i32 {
         Lt { v: 2 },
     ])));
     {
-        let __n = RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>).to_end())
-            .iter_distance(&RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>)));
+        let __n = (lts.as_pointer() as Ptr<Lt>)
+            .end()
+            .iter_distance(&(lts.as_pointer() as Ptr<Lt>).begin());
         let mut __order: Vec<isize> = (0..__n).collect();
         __order.sort_by(|&__x, &__y| {
-            RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>))
+            (lts.as_pointer() as Ptr<Lt>)
+                .begin()
                 .iter_at(__x)
                 .with(|__a| {
-                    RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>))
+                    (lts.as_pointer() as Ptr<Lt>)
+                        .begin()
                         .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()
-            })
+            .map(|&__i| (lts.as_pointer() as Ptr<Lt>).begin().iter_at(__i).read())
             .collect();
         for (__i, __v) in (0..__n).zip(__values) {
-            RandomAccessIterator::Vec((lts.as_pointer() as Ptr<Lt>))
+            (lts.as_pointer() as Ptr<Lt>)
+                .begin()
                 .iter_at(__i)
                 .write(__v);
         }
@@ -204,8 +204,8 @@ fn main_0() -> i32 {
     let mut nine: Eq = Eq { v: 9 };
     assert!(
         ({
-            let mut __it = RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>));
-            while __it != RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>).to_end())
+            let mut __it = (eqs.as_pointer() as Ptr<Eq>).begin();
+            while __it != (eqs.as_pointer() as Ptr<Eq>).end()
                 && __it.iter_deref().with(|__v| *__v != two)
             {
                 __it.iter_inc();
@@ -218,14 +218,14 @@ fn main_0() -> i32 {
     );
     assert!(
         {
-            let mut __it = RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>));
-            while __it != RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>).to_end())
+            let mut __it = (eqs.as_pointer() as Ptr<Eq>).begin();
+            while __it != (eqs.as_pointer() as Ptr<Eq>).end()
                 && __it.iter_deref().with(|__v| *__v != nine)
             {
                 __it.iter_inc();
             }
             __it
-        } == RandomAccessIterator::Vec((eqs.as_pointer() as Ptr<Eq>).to_end())
+        } == (eqs.as_pointer() as Ptr<Eq>).end()
     );
     let cmps: Value<Vec<Cmp>> = Rc::new(RefCell::new(Vec::from([
         Cmp { v: 3 },
@@ -233,28 +233,28 @@ fn main_0() -> i32 {
         Cmp { v: 2 },
     ])));
     {
-        let __n = RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>).to_end())
-            .iter_distance(&RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>)));
+        let __n = (cmps.as_pointer() as Ptr<Cmp>)
+            .end()
+            .iter_distance(&(cmps.as_pointer() as Ptr<Cmp>).begin());
         let mut __order: Vec<isize> = (0..__n).collect();
         __order.sort_by(|&__x, &__y| {
-            RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>))
+            (cmps.as_pointer() as Ptr<Cmp>)
+                .begin()
                 .iter_at(__x)
                 .with(|__a| {
-                    RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>))
+                    (cmps.as_pointer() as Ptr<Cmp>)
+                        .begin()
                         .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()
-            })
+            .map(|&__i| (cmps.as_pointer() as Ptr<Cmp>).begin().iter_at(__i).read())
             .collect();
         for (__i, __v) in (0..__n).zip(__values) {
-            RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>))
+            (cmps.as_pointer() as Ptr<Cmp>)
+                .begin()
                 .iter_at(__i)
                 .write(__v);
         }
@@ -263,8 +263,8 @@ fn main_0() -> i32 {
     let mut three: Cmp = Cmp { v: 3 };
     assert!(
         ({
-            let mut __it = RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>));
-            while __it != RandomAccessIterator::Vec((cmps.as_pointer() as Ptr<Cmp>).to_end())
+            let mut __it = (cmps.as_pointer() as Ptr<Cmp>).begin();
+            while __it != (cmps.as_pointer() as Ptr<Cmp>).end()
                 && __it.iter_deref().with(|__v| *__v != three)
             {
                 __it.iter_inc();
@@ -277,16 +277,17 @@ fn main_0() -> i32 {
     );
     let frees: Value<Vec<Free>> = Rc::new(RefCell::new(Vec::from([Free { v: 2 }, Free { v: 1 }])));
     {
-        let __n = RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>).to_end())
-            .iter_distance(&RandomAccessIterator::Vec(
-                (frees.as_pointer() as Ptr<Free>),
-            ));
+        let __n = (frees.as_pointer() as Ptr<Free>)
+            .end()
+            .iter_distance(&(frees.as_pointer() as Ptr<Free>).begin());
         let mut __order: Vec<isize> = (0..__n).collect();
         __order.sort_by(|&__x, &__y| {
-            RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>))
+            (frees.as_pointer() as Ptr<Free>)
+                .begin()
                 .iter_at(__x)
                 .with(|__a| {
-                    RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>))
+                    (frees.as_pointer() as Ptr<Free>)
+                        .begin()
                         .iter_at(__y)
                         .with(|__b| __a.cmp(__b))
                 })
@@ -294,13 +295,15 @@ fn main_0() -> i32 {
         let __values: Vec<_> = __order
             .iter()
             .map(|&__i| {
-                RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>))
+                (frees.as_pointer() as Ptr<Free>)
+                    .begin()
                     .iter_at(__i)
                     .read()
             })
             .collect();
         for (__i, __v) in (0..__n).zip(__values) {
-            RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>))
+            (frees.as_pointer() as Ptr<Free>)
+                .begin()
                 .iter_at(__i)
                 .write(__v);
         }
@@ -309,8 +312,8 @@ fn main_0() -> i32 {
     let mut ftwo: Free = Free { v: 2 };
     assert!(
         ({
-            let mut __it = RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>));
-            while __it != RandomAccessIterator::Vec((frees.as_pointer() as Ptr<Free>).to_end())
+            let mut __it = (frees.as_pointer() as Ptr<Free>).begin();
+            while __it != (frees.as_pointer() as Ptr<Free>).end()
                 && __it.iter_deref().with(|__v| *__v != ftwo)
             {
                 __it.iter_inc();
diff --git a/tests/unit/out/refcount/sort.rs b/tests/unit/out/refcount/sort.rs
index a0ec040ff..e04700c5c 100644
--- a/tests/unit/out/refcount/sort.rs
+++ b/tests/unit/out/refcount/sort.rs
@@ -53,30 +53,27 @@ fn main_0() -> i32 {
         (*v.borrow_mut()).push(__a1)
     };
     {
-        let __n = RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>).to_end())
-            .iter_distance(&RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>)));
+        let __n = (v.as_pointer() as Ptr<i32>)
+            .end()
+            .iter_distance(&(v.as_pointer() as Ptr<i32>).begin());
         let mut __order: Vec<isize> = (0..__n).collect();
         __order.sort_by(|&__x, &__y| {
-            RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+            (v.as_pointer() as Ptr<i32>)
+                .begin()
                 .iter_at(__x)
                 .with(|__a| {
-                    RandomAccessIterator::Vec((v.as_pointer() as Ptr<i32>))
+                    (v.as_pointer() as Ptr<i32>)
+                        .begin()
                         .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()
-            })
+            .map(|&__i| (v.as_pointer() as Ptr<i32>).begin().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);
+            (v.as_pointer() as Ptr<i32>).begin().iter_at(__i).write(__v);
         }
     };
     let mut i: u32 = 0_u32;
diff --git a/tests/unit/out/refcount/split_binop_aliased_borrows.rs b/tests/unit/out/refcount/split_binop_aliased_borrows.rs
index f78f497c7..72746798c 100644
--- a/tests/unit/out/refcount/split_binop_aliased_borrows.rs
+++ b/tests/unit/out/refcount/split_binop_aliased_borrows.rs
@@ -11,10 +11,9 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let v: Value<Vec<i32>> = Rc::new(RefCell::new(Vec::from([1, 2])));
-    let p: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(RandomAccessIterator::Vec(
-        (v.as_pointer() as Ptr<i32>),
-    )));
+    let v: Value<Vec<i32>> = Rc::new(RefCell::new(vec![1, 2]));
+    let p: Value<RandomAccessIterator<i32>> =
+        Rc::new(RefCell::new((v.as_pointer() as Ptr<i32>).begin()));
     let r: Ptr<i32> = (v.as_pointer() as Ptr<i32>).offset(1_usize);
     let __rhs = (r.read());
     (*p.borrow()).iter_deref().write(__rhs);
diff --git a/tests/unit/out/refcount/unboxed_conditional_iterator.rs b/tests/unit/out/refcount/unboxed_conditional_iterator.rs
index e982083f9..949e2988d 100644
--- a/tests/unit/out/refcount/unboxed_conditional_iterator.rs
+++ b/tests/unit/out/refcount/unboxed_conditional_iterator.rs
@@ -48,8 +48,8 @@ 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 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())
+            let mut __it = (items.as_pointer() as Ptr<u32>).begin();
+            while __it != (items.as_pointer() as Ptr<u32>).end()
                 && __it
                     .iter_deref()
                     .with(|__v| *__v != (elem!(sigma, i).read()))
@@ -58,12 +58,9 @@ pub fn lehmer_2(mut sigma: Ptr<u32>, mut len: u32, mut code: Ptr<u32>) {
             }
             __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);
+        assert!((*it.borrow()) != (items.as_pointer() as Ptr<u32>).end());
+        let __rhs =
+            ((*it.borrow()).iter_distance(&(items.as_pointer() as Ptr<u32>).begin()) as u32);
         elem!(code, i).write(__rhs);
         {
             let idx = <RandomAccessIterator<u32>>::from((*it.borrow()).clone())
@@ -77,12 +74,10 @@ pub fn lehmer_2(mut sigma: Ptr<u32>, mut len: u32, mut code: Ptr<u32>) {
 }
 pub fn sum_3(v: Ptr<Vec<i32>>) -> i32 {
     let mut s: i32 = 0;
-    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())
-    {
+    let it: Value<RandomAccessIterator<i32>> = Rc::new(RefCell::new(
+        (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>).begin(),
+    ));
+    'loop_: while (*it.borrow()) != (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>).end() {
         s += ((*it.borrow()).iter_deref().read());
         (*it.borrow_mut()).iter_inc();
     }
diff --git a/tests/unit/out/refcount/unboxed_locals.rs b/tests/unit/out/refcount/unboxed_locals.rs
index c26605f2e..94e5196c4 100644
--- a/tests/unit/out/refcount/unboxed_locals.rs
+++ b/tests/unit/out/refcount/unboxed_locals.rs
@@ -22,8 +22,11 @@ pub struct Pair {
 }
 pub fn total_2(v: Ptr<Vec<i32>>) -> i32 {
     let mut s: i32 = 0;
-    'loop_: for mut x in Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32> {
-        let mut x: i32 = x.read();
+    'loop_: for x in IterRange::new(
+        (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>).begin(),
+        (Ptr::<Vec<i32>>::decay(&(v)) as Ptr<i32>).end(),
+    ) {
+        let mut x: i32 = (x.iter_deref().read());
         s += x;
     }
     return s;
diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs
index 9cb8df477..b74721bc1 100644
--- a/tests/unit/out/refcount/vector.rs
+++ b/tests/unit/out/refcount/vector.rs
@@ -55,11 +55,9 @@ fn main_0() -> i32 {
     };
     assert!(((*v2.borrow()).len() == 3_usize));
     {
-        let idx = <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec(
-            (v2.as_pointer() as Ptr<i32>),
-        ))
-        .vec_ptr()
-        .get_offset();
+        let idx = <RandomAccessIterator<i32>>::from((v2.as_pointer() as Ptr<i32>).begin())
+            .vec_ptr()
+            .get_offset();
         (v2.as_pointer() as Ptr<Vec<i32>>).with_mut(|__v: &mut Vec<i32>| __v.remove(idx));
         RandomAccessIterator::Vec((v2.as_pointer() as Ptr<Vec<i32>>).decay())
     };
@@ -67,13 +65,11 @@ fn main_0() -> i32 {
     assert!(({ (*v2.borrow())[0_usize] } == 2));
     assert!(({ (*v2.borrow())[1_usize] } == 3));
     {
-        let __off = <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec(
-            (v2.as_pointer() as Ptr<i32>),
-        ))
-        .vec_ptr()
-        .get_offset();
+        let __off = <RandomAccessIterator<i32>>::from((v2.as_pointer() as Ptr<i32>).begin())
+            .vec_ptr()
+            .get_offset();
         (*v2.borrow_mut()).insert(__off, 100);
-        <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr<i32>)))
+        <RandomAccessIterator<i32>>::from((v2.as_pointer() as Ptr<i32>).begin())
     };
     ({ copy_0((*v2.borrow()).clone()) });
     assert!(((*v2.borrow()).len() == 3_usize));
diff --git a/tests/unit/out/refcount/vector3.rs b/tests/unit/out/refcount/vector3.rs
index 0333ddd72..f29da1f9a 100644
--- a/tests/unit/out/refcount/vector3.rs
+++ b/tests/unit/out/refcount/vector3.rs
@@ -29,21 +29,43 @@ fn main_0() -> i32 {
     index!(elem!((v.as_pointer() as Ptr<Vec<i32>>), 0_usize), 0_usize).write(1);
     index!(elem!((v.as_pointer() as Ptr<Vec<i32>>), 0_usize), 1_usize).write(5);
     index!(elem!((v.as_pointer() as Ptr<Vec<i32>>), 1_usize), 0_usize).write(6);
-    'loop_: for mut v2 in v.as_pointer() as Ptr<Vec<i32>> {
-        'loop_: for mut i in Ptr::<Vec<i32>>::decay(&(v2)) as Ptr<i32> {
+    'loop_: for v2 in IterRange::new(
+        (v.as_pointer() as Ptr<Vec<i32>>).begin(),
+        (v.as_pointer() as Ptr<Vec<i32>>).end(),
+    ) {
+        let v2: Ptr<Vec<i32>> = v2.iter_deref();
+        'loop_: for i in IterRange::new(
+            (Ptr::<Vec<i32>>::decay(&(v2)) as Ptr<i32>).begin(),
+            (Ptr::<Vec<i32>>::decay(&(v2)) as Ptr<i32>).end(),
+        ) {
+            let i: Ptr<i32> = i.iter_deref();
             i.with_mut(|__v| __v.prefix_inc());
         }
     }
-    'loop_: for mut v2 in v.as_pointer() as Ptr<Vec<i32>> {
-        'loop_: for mut i in Ptr::<Vec<i32>>::decay(&(v2)) as Ptr<i32> {
-            let mut i: i32 = i.read();
+    'loop_: for v2 in IterRange::new(
+        (v.as_pointer() as Ptr<Vec<i32>>).begin(),
+        (v.as_pointer() as Ptr<Vec<i32>>).end(),
+    ) {
+        let v2: Ptr<Vec<i32>> = v2.iter_deref();
+        'loop_: for i in IterRange::new(
+            (Ptr::<Vec<i32>>::decay(&(v2)) as Ptr<i32>).begin(),
+            (Ptr::<Vec<i32>>::decay(&(v2)) as Ptr<i32>).end(),
+        ) {
+            let mut i: i32 = (i.iter_deref().read());
             println!("{}", (i + 3));
         }
     }
-    'loop_: for mut v2 in v.as_pointer() as Ptr<Vec<i32>> {
-        let v2: Value<Vec<i32>> = Rc::new(RefCell::new(v2.upgrade().deref().clone()));
-        'loop_: for mut i in v2.as_pointer() as Ptr<i32> {
-            let mut i: i32 = i.read();
+    'loop_: for v2 in IterRange::new(
+        (v.as_pointer() as Ptr<Vec<i32>>).begin(),
+        (v.as_pointer() as Ptr<Vec<i32>>).end(),
+    ) {
+        let v2: Value<Vec<i32>> =
+            Rc::new(RefCell::new((*v2.iter_deref().upgrade().deref()).clone()));
+        'loop_: for i in IterRange::new(
+            (v2.as_pointer() as Ptr<i32>).begin(),
+            (v2.as_pointer() as Ptr<i32>).end(),
+        ) {
+            let mut i: i32 = (i.iter_deref().read());
             println!("{}", i);
         }
     }
diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs
index 9af36ebc9..382795fa5 100644
--- a/tests/unit/out/refcount/vector_with_allocator.rs
+++ b/tests/unit/out/refcount/vector_with_allocator.rs
@@ -100,11 +100,9 @@ fn main_0() -> i32 {
     };
     assert!(((*v2.borrow()).len() == 3_usize));
     {
-        let idx = <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec(
-            (v2.as_pointer() as Ptr<i32>),
-        ))
-        .vec_ptr()
-        .get_offset();
+        let idx = <RandomAccessIterator<i32>>::from((v2.as_pointer() as Ptr<i32>).begin())
+            .vec_ptr()
+            .get_offset();
         (v2.as_pointer() as Ptr<Vec<i32>>).with_mut(|__v: &mut Vec<i32>| __v.remove(idx));
         RandomAccessIterator::Vec((v2.as_pointer() as Ptr<Vec<i32>>).decay())
     };
@@ -112,13 +110,11 @@ fn main_0() -> i32 {
     assert!(({ (*v2.borrow())[0_usize] } == 2));
     assert!(({ (*v2.borrow())[1_usize] } == 3));
     {
-        let __off = <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec(
-            (v2.as_pointer() as Ptr<i32>),
-        ))
-        .vec_ptr()
-        .get_offset();
+        let __off = <RandomAccessIterator<i32>>::from((v2.as_pointer() as Ptr<i32>).begin())
+            .vec_ptr()
+            .get_offset();
         (*v2.borrow_mut()).insert(__off, 100);
-        <RandomAccessIterator<i32>>::from(RandomAccessIterator::Vec((v2.as_pointer() as Ptr<i32>)))
+        <RandomAccessIterator<i32>>::from((v2.as_pointer() as Ptr<i32>).begin())
     };
     ({ 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 fb8f6cab5..7a852ca37 100644
--- a/tests/unit/out/refcount/void_return.rs
+++ b/tests/unit/out/refcount/void_return.rs
@@ -58,10 +58,8 @@ pub fn main() {
 fn main_0() -> i32 {
     let v: Value<Vec<i32>> = Rc::new(RefCell::new(Vec::from([1, 3, 0, 2, 8, 7])));
     ({
-        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());
+        let _first: RandomAccessIterator<i32> = (v.as_pointer() as Ptr<i32>).begin();
+        let _last: RandomAccessIterator<i32> = (v.as_pointer() as Ptr<i32>).end();
         f1_0(_first, _last)
     });
     let a: Value<Box<[i32]>> = Rc::new(RefCell::new(Box::new([1, 2, 3])));
diff --git a/tests/unit/out/unsafe/auto.rs b/tests/unit/out/unsafe/auto.rs
index 86967b657..8a5f25a2d 100644
--- a/tests/unit/out/unsafe/auto.rs
+++ b/tests/unit/out/unsafe/auto.rs
@@ -26,8 +26,8 @@ unsafe fn main_0() -> i32 {
         v.push(__a1)
     };
     let mut sum: i32 = 0;
-    'loop_: for elem in 0..(v.len()) {
-        let mut elem = v[elem].clone();
+    'loop_: for elem in IterRange::new(v.begin(), v.end()) {
+        let mut elem: i32 = (*elem.iter_deref());
         sum += elem;
     }
     assert!(((sum) == (3)));
diff --git a/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs b/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs
index e34a538c7..ff68cccfe 100644
--- a/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs
+++ b/tests/unit/out/unsafe/elidable_iterator_copy_cxx11.rs
@@ -23,46 +23,31 @@ unsafe fn main_0() -> i32 {
         v.push(__a1)
     };
     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
-        {
+        let mut __it = v.begin();
+        while __it != v.end() && *__it.iter_deref() != 7 {
             __it.iter_inc();
         }
         __it
     };
-    assert!(it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len())));
+    assert!(it != v.end());
     assert!(((*it.iter_deref()) == (7)));
     {
-        let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()))
-            .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()));
+        let __n = v.end().iter_distance(&v.begin());
         for __i in (1..__n).rev() {
             let __j = libc::rand() as isize % (__i + 1);
-            std::ptr::swap(
-                UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i),
-                UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__j),
-            );
+            std::ptr::swap(v.begin().iter_at(__i), v.begin().iter_at(__j));
         }
     };
     {
-        let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()))
-            .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()));
+        let __n = v.end().iter_distance(&v.begin());
         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))
-        });
+        __order.sort_by(|&__x, &__y| (*v.begin().iter_at(__x)).cmp(&*v.begin().iter_at(__y)));
         let __values: Vec<_> = __order
             .iter()
-            .map(|&__i| {
-                std::ptr::read(UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i))
-            })
+            .map(|&__i| std::ptr::read(v.begin().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,
-            );
+            std::ptr::write(v.begin().iter_at(__i), __v);
         }
     };
     assert!(((v[(0_usize)]) == (4)) && ((v[(1_usize)]) == (7)));
diff --git a/tests/unit/out/unsafe/find.rs b/tests/unit/out/unsafe/find.rs
index 6c9200908..7a050d5b1 100644
--- a/tests/unit/out/unsafe/find.rs
+++ b/tests/unit/out/unsafe/find.rs
@@ -26,10 +26,8 @@ unsafe fn main_0() -> i32 {
         let __a1 = 3;
         v.push(__a1)
     };
-    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 v_begin: UnsafeRandomAccessIterator<i32> = v.begin();
+    let mut v_end: UnsafeRandomAccessIterator<i32> = v.end();
     let mut it: UnsafeRandomAccessIterator<i32> = {
         let mut __it = (v_begin).clone();
         while __it != (v_end).clone() && *__it.iter_deref() != 2 {
@@ -37,8 +35,7 @@ unsafe fn main_0() -> i32 {
         }
         __it
     };
-    let mut v_result_true: bool =
-        it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()));
+    let mut v_result_true: bool = it != v.end();
     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;
@@ -49,48 +46,40 @@ unsafe fn main_0() -> i32 {
     assert!(
         ((v_result_true) && (m_result_true))
             && ({
-                let mut __it = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr());
-                while __it != UnsafeRandomAccessIterator::Vec(v.as_mut_ptr())
-                    && *__it.iter_deref() != 2
-                {
+                let mut __it = v.begin();
+                while __it != v.begin() && *__it.iter_deref() != 2 {
                     __it.iter_inc();
                 }
                 __it
-            } == UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()))
+            } == v.begin())
     );
     let mut w: Vec<i32> = Vec::from([1, 2, 3, 4, 5]);
     assert!(
         {
-            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
-            {
+            let mut __it = w.begin().iter_add(2_isize);
+            while __it != w.end() && *__it.iter_deref() != 4 {
                 __it.iter_inc();
             }
             __it
-        } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(3_isize)
+        } == w.begin().iter_add(3_isize)
     );
     assert!(
         {
-            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
-            {
+            let mut __it = w.begin().iter_add(2_isize);
+            while __it != w.end() && *__it.iter_deref() != 1 {
                 __it.iter_inc();
             }
             __it
-        } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr().add(w.len()))
+        } == w.end()
     );
     assert!(
         {
-            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
-            {
+            let mut __it = w.begin().iter_add(2_isize);
+            while __it != w.begin().iter_add(4_isize) && *__it.iter_deref() != 5 {
                 __it.iter_inc();
             }
             __it
-        } == UnsafeRandomAccessIterator::Vec(w.as_mut_ptr()).iter_add(4_isize)
+        } == w.begin().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 814c7ced9..1e52426a1 100644
--- a/tests/unit/out/unsafe/fn_ptr_stable_sort.rs
+++ b/tests/unit/out/unsafe/fn_ptr_stable_sort.rs
@@ -36,12 +36,11 @@ unsafe fn main_0() -> i32 {
         v.push(__a1)
     };
     {
-        let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()))
-            .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()));
+        let __n = v.end().iter_distance(&v.begin());
         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 _;
+            let __a = v.begin().iter_at(__x) as *const _;
+            let __b = v.begin().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(__b, __a) {
@@ -52,15 +51,10 @@ unsafe fn main_0() -> i32 {
         });
         let __values: Vec<_> = __order
             .iter()
-            .map(|&__i| {
-                std::ptr::read(UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i))
-            })
+            .map(|&__i| std::ptr::read(v.begin().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,
-            );
+            std::ptr::write(v.begin().iter_at(__i), __v);
         }
     };
     assert!(((v[(0_usize)].key) == (1)));
diff --git a/tests/unit/out/unsafe/foreach.rs b/tests/unit/out/unsafe/foreach.rs
index d6d231fb2..79f288c1b 100644
--- a/tests/unit/out/unsafe/foreach.rs
+++ b/tests/unit/out/unsafe/foreach.rs
@@ -23,8 +23,8 @@ unsafe fn main_0() -> i32 {
         i.prefix_inc();
     }
     let mut sum: i32 = 0;
-    'loop_: for x in 0..(v.len()) {
-        let mut x = v[x].clone();
+    'loop_: for x in IterRange::new(v.begin(), v.end()) {
+        let mut x: i32 = (*x.iter_deref());
         sum += x;
     }
     assert!(((sum) == (45)));
diff --git a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs
index 8ab6a468e..9821d8d7a 100644
--- a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs
+++ b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs
@@ -24,8 +24,8 @@ unsafe fn main_0() -> i32 {
         let __a1 = 1;
         s.v.push(__a1)
     };
-    'loop_: for e in 0..(s.v.len()) {
-        let mut e = s.v[e].clone();
+    'loop_: for e in IterRange::new(s.v.begin(), s.v.end()) {
+        let mut e: i32 = (*e.iter_deref());
         s.a.postfix_inc();
     }
     return 0;
diff --git a/tests/unit/out/unsafe/foreach_double.rs b/tests/unit/out/unsafe/foreach_double.rs
index 7c6e3f33a..da7b346da 100644
--- a/tests/unit/out/unsafe/foreach_double.rs
+++ b/tests/unit/out/unsafe/foreach_double.rs
@@ -27,31 +27,31 @@ unsafe fn main_0() -> i32 {
         v.push(__a1)
     };
     let mut square: i32 = 0;
-    'loop_: for e1 in 0..(v.len()) {
-        let mut e1 = v[e1].clone();
-        'loop_: for e2 in 0..(v.len()) {
-            let mut e2 = v[e2].clone();
+    'loop_: for e1 in IterRange::new(v.begin(), v.end()) {
+        let mut e1: i32 = (*e1.iter_deref());
+        'loop_: for e2 in IterRange::new(v.begin(), v.end()) {
+            let mut e2: i32 = (*e2.iter_deref());
             square += ((e1) * (e2));
         }
     }
-    'loop_: for e1 in 0..(v.len()) {
-        let mut e1 = v.as_mut_ptr().add(e1);
-        'loop_: for e2 in 0..(v.len()) {
-            let mut e2 = v.as_ptr().add(e2);
+    'loop_: for e1 in IterRange::new(v.begin(), v.end()) {
+        let e1: *mut i32 = &mut (*e1.iter_deref());
+        'loop_: for e2 in IterRange::new(v.begin(), v.end()) {
+            let e2: *const i32 = &(*e2.iter_deref());
             square += ((*e1) * (*e2));
         }
     }
-    'loop_: for e1 in 0..(v.len()) {
-        let mut e1 = v.as_ptr().add(e1);
-        'loop_: for e2 in 0..(v.len()) {
-            let mut e2 = v.as_mut_ptr().add(e2);
+    'loop_: for e1 in IterRange::new(v.begin(), v.end()) {
+        let e1: *const i32 = &(*e1.iter_deref());
+        'loop_: for e2 in IterRange::new(v.begin(), v.end()) {
+            let e2: *mut i32 = &mut (*e2.iter_deref());
             square += ((*e1) * (*e2));
         }
     }
-    'loop_: for e1 in 0..(v.len()) {
-        let mut e1 = v.as_mut_ptr().add(e1);
-        'loop_: for e2 in 0..(v.len()) {
-            let mut e2 = v.as_mut_ptr().add(e2);
+    'loop_: for e1 in IterRange::new(v.begin(), v.end()) {
+        let e1: *mut i32 = &mut (*e1.iter_deref());
+        'loop_: for e2 in IterRange::new(v.begin(), v.end()) {
+            let e2: *mut i32 = &mut (*e2.iter_deref());
             square += ((*e1) * (*e2));
         }
     }
@@ -71,10 +71,10 @@ unsafe fn main_0() -> i32 {
         let __a1 = std::mem::take(&mut v3);
         m.push(__a1)
     };
-    'loop_: for row in 0..(m.len()) {
-        let mut row = m.as_mut_ptr().add(row);
-        'loop_: for col in 0..((*row).len()) {
-            let mut col = (*row).as_mut_ptr().add(col);
+    'loop_: for row in IterRange::new(m.begin(), m.end()) {
+        let row: *mut Vec<i32> = &mut (*row.iter_deref());
+        'loop_: for col in IterRange::new((*row).begin(), (*row).end()) {
+            let col: *mut i32 = &mut (*col.iter_deref());
             square += (*col);
         }
     }
diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs
index f959c4322..0e0ea4f17 100644
--- a/tests/unit/out/unsafe/foreach_map.rs
+++ b/tests/unit/out/unsafe/foreach_map.rs
@@ -25,22 +25,22 @@ unsafe fn main_0() -> i32 {
         };
     }
     let mut sum: f64 = 0_f64;
-    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, f64)>) {
-        let i: *const (i32, f64) = &(*__begin1.iter_deref());
+    'loop_: for i in IterRange::new(m.begin(), m.end()) {
+        let i: *const (i32, f64) = &(*i.iter_deref());
         sum += (*i).1;
     }
-    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, f64)>) {
-        let mut i: (i32, f64) = (*__begin1.iter_deref()).clone();
+    'loop_: for i in IterRange::new(m.begin(), m.end()) {
+        let mut i: (i32, f64) = (*i.iter_deref()).clone();
         sum += (i.0 as f64);
     }
     assert!(((sum) == (7475_f64)));
-    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, f64)>) {
-        let mut i: (i32, f64) = (*__begin1.iter_deref()).clone();
+    'loop_: for i in IterRange::new(m.begin(), m.end()) {
+        let mut i: (i32, f64) = (*i.iter_deref()).clone();
         i.1 = (-1_i32 as f64);
         assert!(((i.1) == (-1_i32 as f64)));
     }
-    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, f64)>) {
-        let i: *const (i32, f64) = &(*__begin1.iter_deref());
+    'loop_: for i in IterRange::new(m.begin(), m.end()) {
+        let i: *const (i32, f64) = &(*i.iter_deref());
         assert!((((*i).1) != (-1_i32 as f64)));
     }
     return 0;
diff --git a/tests/unit/out/unsafe/foreach_mut.rs b/tests/unit/out/unsafe/foreach_mut.rs
index d3dce8649..3b6869788 100644
--- a/tests/unit/out/unsafe/foreach_mut.rs
+++ b/tests/unit/out/unsafe/foreach_mut.rs
@@ -27,20 +27,20 @@ unsafe fn main_0() -> i32 {
         v1.push(__a1)
     };
     let mut sum: i32 = 0;
-    'loop_: for x in 0..(v1.len()) {
-        let mut x = v1[x].clone();
+    'loop_: for x in IterRange::new(v1.begin(), v1.end()) {
+        let mut x: i32 = (*x.iter_deref());
         sum += x.prefix_inc();
     }
-    'loop_: for x in 0..(v1.len()) {
-        let x = v1[x].clone();
+    'loop_: for x in IterRange::new(v1.begin(), v1.end()) {
+        let x: i32 = (*x.iter_deref());
         sum += x;
     }
-    'loop_: for x in 0..(v1.len()) {
-        let mut x = v1.as_mut_ptr().add(x);
+    'loop_: for x in IterRange::new(v1.begin(), v1.end()) {
+        let x: *mut i32 = &mut (*x.iter_deref());
         (*x) += 10;
     }
-    'loop_: for x in 0..(v1.len()) {
-        let mut x = v1.as_ptr().add(x);
+    'loop_: for x in IterRange::new(v1.begin(), v1.end()) {
+        let x: *const i32 = &(*x.iter_deref());
         sum += (*x);
     }
     let mut v2: Vec<*mut i32> = Vec::new();
@@ -56,20 +56,20 @@ unsafe fn main_0() -> i32 {
         let __a1 = (&mut v1[(2_usize)] as *mut i32);
         v2.push(__a1)
     };
-    'loop_: for p in 0..(v2.len()) {
-        let mut p = v2[p].clone();
+    'loop_: for p in IterRange::new(v2.begin(), v2.end()) {
+        let mut p: *mut i32 = (*p.iter_deref());
         (*p) += 5;
     }
-    'loop_: for p in 0..(v2.len()) {
-        let p = v2[p].clone();
+    'loop_: for p in IterRange::new(v2.begin(), v2.end()) {
+        let p: *mut i32 = (*p.iter_deref());
         sum += (*p);
     }
-    'loop_: for p in 0..(v2.len()) {
-        let mut p = v2[p].clone();
+    'loop_: for p in IterRange::new(v2.begin(), v2.end()) {
+        let mut p: *mut i32 = (*p.iter_deref());
         (*p) += 5;
     }
-    'loop_: for p in 0..(v2.len()) {
-        let mut p = v2[p].clone();
+    'loop_: for p in IterRange::new(v2.begin(), v2.end()) {
+        let mut p: *const i32 = (*p.iter_deref()).cast_const();
         sum += (*p);
     }
     assert!(((sum) == (168)));
diff --git a/tests/unit/out/unsafe/iterator_freshness.rs b/tests/unit/out/unsafe/iterator_freshness.rs
index a3ddb1f65..1c1756e6a 100644
--- a/tests/unit/out/unsafe/iterator_freshness.rs
+++ b/tests/unit/out/unsafe/iterator_freshness.rs
@@ -17,8 +17,7 @@ unsafe fn main_0() -> i32 {
     let mut vec_: Vec<i32> = (0..(4_usize) as usize)
         .map(|_| <i32>::default())
         .collect::<Vec<_>>();
-    let mut it: UnsafeRandomAccessIterator<i32> =
-        UnsafeRandomAccessIterator::Vec(vec_.as_mut_ptr());
+    let mut it: UnsafeRandomAccessIterator<i32> = vec_.begin();
     (unsafe { foo_0((it).clone()) });
     return 0;
 }
diff --git a/tests/unit/out/unsafe/iterators.rs b/tests/unit/out/unsafe/iterators.rs
index 66d08982d..b2389c057 100644
--- a/tests/unit/out/unsafe/iterators.rs
+++ b/tests/unit/out/unsafe/iterators.rs
@@ -17,16 +17,16 @@ unsafe fn main_0() -> i32 {
         let s = c"hello".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
-    'loop_: for c in 0..(x.len() - 1) {
-        let mut c = x.as_mut_ptr().add(c);
+    'loop_: for c in IterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) {
+        let c: *mut libc::c_char = &mut (*c.iter_deref());
         (*c).prefix_inc();
     }
-    'loop_: for c in 0..(x.len() - 1) {
-        let mut c = x.as_mut_ptr().add(c);
+    'loop_: for c in IterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) {
+        let c: *mut libc::c_char = &mut (*c.iter_deref());
         (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, ((*c) as i32)) });
     }
-    'loop_: for c in 0..(x.len() - 1) {
-        let mut c = x[c].clone();
+    'loop_: for c in IterRange::new(x.as_mut_ptr(), x.as_mut_ptr().add(x.len() - 1)) {
+        let mut c: libc::c_char = (*c.iter_deref());
         (unsafe { libc::printf(c"%c\n".as_ptr() as *const libc::c_char, (c as i32)) });
     }
     let mut v: Vec<*mut i32> = Vec::new();
@@ -38,8 +38,8 @@ unsafe fn main_0() -> i32 {
         let __a1 = (Box::leak(Box::new(3)) as *mut i32);
         v.push(__a1)
     };
-    'loop_: for p in 0..(v.len()) {
-        let mut p = v[p].clone();
+    'loop_: for p in IterRange::new(v.begin(), v.end()) {
+        let mut p: *mut i32 = (*p.iter_deref());
         (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (*p)) });
     }
     return 0;
diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs
index aeb19296b..8b3bddbd8 100644
--- a/tests/unit/out/unsafe/map-reallocation.rs
+++ b/tests/unit/out/unsafe/map-reallocation.rs
@@ -58,8 +58,8 @@ unsafe fn main_0() -> i32 {
     assert!(((*p) == (57005)));
     assert!(((m.len()) == ((((N) + (1)) as u32) as usize)));
     let mut prev: i32 = -1_i32;
-    'loop_: for __begin1 in UnsafeMap::range(&m as *const UnsafeMap<i32, (i32, i32)>) {
-        let pair: *mut (i32, i32) = &mut (*__begin1.iter_deref());
+    'loop_: for pair in IterRange::new(m.begin(), m.end()) {
+        let pair: *mut (i32, i32) = &mut (*pair.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 93a688ead..58d16941c 100644
--- a/tests/unit/out/unsafe/map.rs
+++ b/tests/unit/out/unsafe/map.rs
@@ -191,8 +191,8 @@ unsafe fn main_0() -> i32 {
     }
     assert!(((m2.len()) == (indexes.len())));
     let mut last: i32 = -1_i32;
-    'loop_: for __begin1 in UnsafeMap::range(&m2 as *const UnsafeMap<i32, (i32, bool)>) {
-        let pair: *mut (i32, bool) = &mut (*__begin1.iter_deref());
+    'loop_: for pair in IterRange::new(m2.begin(), m2.end()) {
+        let pair: *mut (i32, bool) = &mut (*pair.iter_deref());
         assert!((((*pair).0) > (last)));
         assert!((((*pair).1 as i32) == (((*pair).0) % (2))));
         last = (*pair).0;
diff --git a/tests/unit/out/unsafe/map_key_identity.rs b/tests/unit/out/unsafe/map_key_identity.rs
index d49b8ea5c..9d82b0548 100644
--- a/tests/unit/out/unsafe/map_key_identity.rs
+++ b/tests/unit/out/unsafe/map_key_identity.rs
@@ -118,8 +118,8 @@ unsafe fn main_0() -> i32 {
         }) as i32))
         != 0;
     let mut distinct_count: usize = 0_usize;
-    'loop_: for __begin1 in UnsafeMap::range(&distinct as *const UnsafeMap<Key, (Key, Mapped)>) {
-        let entry: *const (Key, Mapped) = &(*__begin1.iter_deref());
+    'loop_: for entry in IterRange::new(distinct.begin(), distinct.end()) {
+        let entry: *const (Key, Mapped) = &(*entry.iter_deref());
         if ((distinct_count) == (0_usize)) {
             ok = ((ok as i32)
                 & (((((*entry).0.order) == (1)) && (((*entry).1.value) == (11))) as i32))
@@ -179,10 +179,8 @@ unsafe fn main_0() -> i32 {
                 as i32))
             != 0;
         let mut equivalent_count: usize = 0_usize;
-        'loop_: for __begin2 in
-            UnsafeMap::range(&equivalent as *const UnsafeMap<Key, (Key, Mapped)>)
-        {
-            let entry: *const (Key, Mapped) = &(*__begin2.iter_deref());
+        'loop_: for entry in IterRange::new(equivalent.begin(), equivalent.end()) {
+            let entry: *const (Key, Mapped) = &(*entry.iter_deref());
             ok = ((ok as i32)
                 & (((((*entry).0.order) == (3)) && (((*entry).1.value) == (31))) as i32))
                 != 0;
diff --git a/tests/unit/out/unsafe/operator_traits.rs b/tests/unit/out/unsafe/operator_traits.rs
index 607a33fea..2fbe26e8c 100644
--- a/tests/unit/out/unsafe/operator_traits.rs
+++ b/tests/unit/out/unsafe/operator_traits.rs
@@ -139,24 +139,15 @@ unsafe fn main_0() -> i32 {
     assert!(((w.v) == (2)));
     let mut lts: Vec<Lt> = Vec::from([Lt { v: 3 }, Lt { v: 1 }, Lt { v: 2 }]);
     {
-        let __n = UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr().add(lts.len()))
-            .iter_distance(&UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()));
+        let __n = lts.end().iter_distance(&lts.begin());
         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))
-        });
+        __order.sort_by(|&__x, &__y| (*lts.begin().iter_at(__x)).cmp(&*lts.begin().iter_at(__y)));
         let __values: Vec<_> = __order
             .iter()
-            .map(|&__i| {
-                std::ptr::read(UnsafeRandomAccessIterator::Vec(lts.as_mut_ptr()).iter_at(__i))
-            })
+            .map(|&__i| std::ptr::read(lts.begin().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,
-            );
+            std::ptr::write(lts.begin().iter_at(__i), __v);
         }
     };
     assert!(
@@ -167,10 +158,8 @@ unsafe fn main_0() -> i32 {
     let mut nine: Eq = Eq { v: 9 };
     assert!(
         (((*{
-            let mut __it = UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr());
-            while __it != UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len()))
-                && *__it.iter_deref() != two
-            {
+            let mut __it = eqs.begin();
+            while __it != eqs.end() && *__it.iter_deref() != two {
                 __it.iter_inc();
             }
             __it
@@ -180,45 +169,32 @@ unsafe fn main_0() -> i32 {
     );
     assert!(
         {
-            let mut __it = UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr());
-            while __it != UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len()))
-                && *__it.iter_deref() != nine
-            {
+            let mut __it = eqs.begin();
+            while __it != eqs.end() && *__it.iter_deref() != nine {
                 __it.iter_inc();
             }
             __it
-        } == UnsafeRandomAccessIterator::Vec(eqs.as_mut_ptr().add(eqs.len()))
+        } == eqs.end()
     );
     let mut cmps: Vec<Cmp> = Vec::from([Cmp { v: 3 }, Cmp { v: 1 }, Cmp { v: 2 }]);
     {
-        let __n = UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr().add(cmps.len()))
-            .iter_distance(&UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()));
+        let __n = cmps.end().iter_distance(&cmps.begin());
         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))
-        });
+        __order.sort_by(|&__x, &__y| (*cmps.begin().iter_at(__x)).cmp(&*cmps.begin().iter_at(__y)));
         let __values: Vec<_> = __order
             .iter()
-            .map(|&__i| {
-                std::ptr::read(UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr()).iter_at(__i))
-            })
+            .map(|&__i| std::ptr::read(cmps.begin().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,
-            );
+            std::ptr::write(cmps.begin().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 = UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr());
-            while __it != UnsafeRandomAccessIterator::Vec(cmps.as_mut_ptr().add(cmps.len()))
-                && *__it.iter_deref() != three
-            {
+            let mut __it = cmps.begin();
+            while __it != cmps.end() && *__it.iter_deref() != three {
                 __it.iter_inc();
             }
             __it
@@ -228,34 +204,24 @@ unsafe fn main_0() -> i32 {
     );
     let mut frees: Vec<Free> = Vec::from([Free { v: 2 }, Free { v: 1 }]);
     {
-        let __n = UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr().add(frees.len()))
-            .iter_distance(&UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()));
+        let __n = frees.end().iter_distance(&frees.begin());
         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))
-        });
+        __order
+            .sort_by(|&__x, &__y| (*frees.begin().iter_at(__x)).cmp(&*frees.begin().iter_at(__y)));
         let __values: Vec<_> = __order
             .iter()
-            .map(|&__i| {
-                std::ptr::read(UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr()).iter_at(__i))
-            })
+            .map(|&__i| std::ptr::read(frees.begin().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,
-            );
+            std::ptr::write(frees.begin().iter_at(__i), __v);
         }
     };
     assert!(((frees[(0_usize)].v) == (1)));
     let mut ftwo: Free = Free { v: 2 };
     assert!(
         (((*{
-            let mut __it = UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr());
-            while __it != UnsafeRandomAccessIterator::Vec(frees.as_mut_ptr().add(frees.len()))
-                && *__it.iter_deref() != ftwo
-            {
+            let mut __it = frees.begin();
+            while __it != frees.end() && *__it.iter_deref() != ftwo {
                 __it.iter_inc();
             }
             __it
diff --git a/tests/unit/out/unsafe/sort.rs b/tests/unit/out/unsafe/sort.rs
index fc4469412..305cb4034 100644
--- a/tests/unit/out/unsafe/sort.rs
+++ b/tests/unit/out/unsafe/sort.rs
@@ -55,24 +55,15 @@ unsafe fn main_0() -> i32 {
         v.push(__a1)
     };
     {
-        let __n = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()))
-            .iter_distance(&UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()));
+        let __n = v.end().iter_distance(&v.begin());
         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))
-        });
+        __order.sort_by(|&__x, &__y| (*v.begin().iter_at(__x)).cmp(&*v.begin().iter_at(__y)));
         let __values: Vec<_> = __order
             .iter()
-            .map(|&__i| {
-                std::ptr::read(UnsafeRandomAccessIterator::Vec(v.as_mut_ptr()).iter_at(__i))
-            })
+            .map(|&__i| std::ptr::read(v.begin().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,
-            );
+            std::ptr::write(v.begin().iter_at(__i), __v);
         }
     };
     let mut i: u32 = 0_u32;
diff --git a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
index e1c2d1d71..d88858f0a 100644
--- a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
+++ b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
@@ -13,8 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut v: Vec<i32> = Vec::from([1, 2]);
-    let mut p: UnsafeRandomAccessIterator<i32> = UnsafeRandomAccessIterator::Vec(v.as_mut_ptr());
+    let mut v: Vec<i32> = vec![1, 2];
+    let mut p: UnsafeRandomAccessIterator<i32> = v.begin();
     let r: *const i32 = &v[(1_usize)];
     (*p.iter_deref()) = (*r);
     assert!(((v[(0_usize)]) == (2)));
diff --git a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
index f703431bc..dffaa8ea8 100644
--- a/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
+++ b/tests/unit/out/unsafe/unboxed_conditional_iterator.rs
@@ -44,17 +44,14 @@ 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: 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))
-            {
+            let mut __it = items.begin();
+            while __it != items.end() && *__it.iter_deref() != (*sigma.offset((i) as isize)) {
                 __it.iter_inc();
             }
             __it
         };
-        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);
+        assert!(it != items.end());
+        (*code.offset((i) as isize)) = (it.iter_distance(&items.begin()) as u32);
         {
             let pos = <UnsafeRandomAccessIterator<u32>>::from((it).clone())
                 .vec_ptr()
@@ -67,9 +64,8 @@ pub unsafe fn lehmer_2(mut sigma: *const u32, mut len: u32, mut code: *mut u32)
 }
 pub unsafe fn sum_3(v: *mut Vec<i32>) -> i32 {
     let mut s: i32 = 0;
-    let mut it: UnsafeRandomAccessIterator<i32> =
-        UnsafeRandomAccessIterator::Vec((*v).as_mut_ptr());
-    'loop_: while it != UnsafeRandomAccessIterator::Vec((*v).as_mut_ptr().add((*v).len())) {
+    let mut it: UnsafeRandomAccessIterator<i32> = (*v).begin();
+    'loop_: while it != (*v).end() {
         s += (*it.iter_deref());
         it.iter_inc();
     }
diff --git a/tests/unit/out/unsafe/unboxed_locals.rs b/tests/unit/out/unsafe/unboxed_locals.rs
index 3cb5a7c08..66905320f 100644
--- a/tests/unit/out/unsafe/unboxed_locals.rs
+++ b/tests/unit/out/unsafe/unboxed_locals.rs
@@ -20,8 +20,8 @@ pub struct Pair {
 }
 pub unsafe fn total_2(v: *const Vec<i32>) -> i32 {
     let mut s: i32 = 0;
-    'loop_: for x in 0..((*v).len()) {
-        let mut x = (&(*v))[x].clone();
+    'loop_: for x in IterRange::new((*v).begin(), (*v).end()) {
+        let mut x: i32 = (*x.iter_deref());
         s += x;
     }
     return s;
diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs
index 06cdf633c..faf70ee93 100644
--- a/tests/unit/out/unsafe/vector.rs
+++ b/tests/unit/out/unsafe/vector.rs
@@ -56,25 +56,21 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((v2.len()) == (3_usize)));
     {
-        let pos = <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(
-            v2.as_mut_ptr(),
-        ))
-        .vec_ptr()
-        .offset_from(v2.as_ptr()) as usize;
+        let pos = <UnsafeRandomAccessIterator<i32>>::from(v2.begin())
+            .vec_ptr()
+            .offset_from(v2.as_ptr()) as usize;
         v2.remove(pos);
-        <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()))
+        <UnsafeRandomAccessIterator<i32>>::from(v2.begin())
     };
     assert!(((v2.len()) == (2_usize)));
     assert!(((v2[(0_usize)]) == (2)));
     assert!(((v2[(1_usize)]) == (3)));
     {
-        let pos = <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(
-            v2.as_mut_ptr(),
-        ))
-        .vec_ptr()
-        .offset_from(v2.as_ptr()) as usize;
+        let pos = <UnsafeRandomAccessIterator<i32>>::from(v2.begin())
+            .vec_ptr()
+            .offset_from(v2.as_ptr()) as usize;
         v2.insert(pos, 100);
-        <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()))
+        <UnsafeRandomAccessIterator<i32>>::from(v2.begin())
     };
     (unsafe { copy_0(v2.clone()) });
     assert!(((v2.len()) == (3_usize)));
diff --git a/tests/unit/out/unsafe/vector3.rs b/tests/unit/out/unsafe/vector3.rs
index 7bb74550e..4b5876414 100644
--- a/tests/unit/out/unsafe/vector3.rs
+++ b/tests/unit/out/unsafe/vector3.rs
@@ -29,24 +29,24 @@ unsafe fn main_0() -> i32 {
     v[(0_usize)][(0_usize)] = 1;
     v[(0_usize)][(1_usize)] = 5;
     v[(1_usize)][(0_usize)] = 6;
-    'loop_: for v2 in 0..(v.len()) {
-        let mut v2 = v.as_mut_ptr().add(v2);
-        'loop_: for i in 0..((*v2).len()) {
-            let mut i = (*v2).as_mut_ptr().add(i);
+    'loop_: for v2 in IterRange::new(v.begin(), v.end()) {
+        let v2: *mut Vec<i32> = &mut (*v2.iter_deref());
+        'loop_: for i in IterRange::new((*v2).begin(), (*v2).end()) {
+            let i: *mut i32 = &mut (*i.iter_deref());
             (*i).prefix_inc();
         }
     }
-    'loop_: for v2 in 0..(v.len()) {
-        let mut v2 = v.as_mut_ptr().add(v2);
-        'loop_: for i in 0..((*v2).len()) {
-            let mut i = (&(*v2))[i].clone();
+    'loop_: for v2 in IterRange::new(v.begin(), v.end()) {
+        let v2: *mut Vec<i32> = &mut (*v2.iter_deref());
+        'loop_: for i in IterRange::new((*v2).begin(), (*v2).end()) {
+            let mut i: i32 = (*i.iter_deref());
             (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, ((i) + (3))) });
         }
     }
-    'loop_: for v2 in 0..(v.len()) {
-        let mut v2 = v[v2].clone();
-        'loop_: for i in 0..(v2.len()) {
-            let mut i = v2[i].clone();
+    'loop_: for v2 in IterRange::new(v.begin(), v.end()) {
+        let mut v2: Vec<i32> = (*v2.iter_deref()).clone();
+        'loop_: for i in IterRange::new(v2.begin(), v2.end()) {
+            let mut i: i32 = (*i.iter_deref());
             (unsafe { libc::printf(c"%d\n".as_ptr() as *const libc::c_char, (i)) });
         }
     }
diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs
index d568aece8..acd93cbfa 100644
--- a/tests/unit/out/unsafe/vector_with_allocator.rs
+++ b/tests/unit/out/unsafe/vector_with_allocator.rs
@@ -131,25 +131,21 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((v2.len()) == (3_usize)));
     {
-        let pos = <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(
-            v2.as_mut_ptr(),
-        ))
-        .vec_ptr()
-        .offset_from(v2.as_ptr()) as usize;
+        let pos = <UnsafeRandomAccessIterator<i32>>::from(v2.begin())
+            .vec_ptr()
+            .offset_from(v2.as_ptr()) as usize;
         v2.remove(pos);
-        <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()))
+        <UnsafeRandomAccessIterator<i32>>::from(v2.begin())
     };
     assert!(((v2.len()) == (2_usize)));
     assert!(((v2[(0_usize)]) == (2)));
     assert!(((v2[(1_usize)]) == (3)));
     {
-        let pos = <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(
-            v2.as_mut_ptr(),
-        ))
-        .vec_ptr()
-        .offset_from(v2.as_ptr()) as usize;
+        let pos = <UnsafeRandomAccessIterator<i32>>::from(v2.begin())
+            .vec_ptr()
+            .offset_from(v2.as_ptr()) as usize;
         v2.insert(pos, 100);
-        <UnsafeRandomAccessIterator<i32>>::from(UnsafeRandomAccessIterator::Vec(v2.as_mut_ptr()))
+        <UnsafeRandomAccessIterator<i32>>::from(v2.begin())
     };
     (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 172434220..dcdda3148 100644
--- a/tests/unit/out/unsafe/void_return.rs
+++ b/tests/unit/out/unsafe/void_return.rs
@@ -50,10 +50,8 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut v: Vec<i32> = Vec::from([1, 3, 0, 2, 8, 7]);
     (unsafe {
-        let _first: UnsafeRandomAccessIterator<i32> =
-            UnsafeRandomAccessIterator::Vec(v.as_mut_ptr());
-        let _last: UnsafeRandomAccessIterator<i32> =
-            UnsafeRandomAccessIterator::Vec(v.as_mut_ptr().add(v.len()));
+        let _first: UnsafeRandomAccessIterator<i32> = v.begin();
+        let _last: UnsafeRandomAccessIterator<i32> = v.end();
         f1_0(_first, _last)
     });
     let mut a: [i32; 3] = [1, 2, 3];