diff --git a/include/unifex/schedule_with_subscheduler.hpp b/include/unifex/schedule_with_subscheduler.hpp
index 94fc5c16..0ae40615 100644
--- a/include/unifex/schedule_with_subscheduler.hpp
+++ b/include/unifex/schedule_with_subscheduler.hpp
@@ -70,7 +70,9 @@ inline const struct _fn {
       operator()(Scheduler&& sched) const -> _result_t<Scheduler> {
     auto&& scheduleOp = schedule(sched);
     return _result_t<Scheduler>{
-        static_cast<decltype(scheduleOp)>(scheduleOp), {(Scheduler &&) sched}};
+        static_cast<decltype(scheduleOp)>(scheduleOp),
+        {(Scheduler &&) sched},
+        instruction_ptr::read_return_address()};
   }
   constexpr auto operator()() const
       noexcept(std::is_nothrow_invocable_v<tag_t<bind_back>, _fn>)
diff --git a/include/unifex/sequence.hpp b/include/unifex/sequence.hpp
index affd58b7..aa3b995c 100644
--- a/include/unifex/sequence.hpp
+++ b/include/unifex/sequence.hpp
@@ -297,11 +297,12 @@ struct _sndr<Predecessor, Successor>::type {
            constructible_from<
                Successor,
                Successor2>)  //
-      explicit type(Predecessor2&& predecessor, Successor2&& successor) noexcept(
+      explicit type(Predecessor2&& predecessor, Successor2&& successor, instruction_ptr returnAddress) noexcept(
           std::is_nothrow_constructible_v<Predecessor, Predecessor2> &&
           std::is_nothrow_constructible_v<Successor, Successor2>)
     : predecessor_(static_cast<Predecessor&&>(predecessor))
-    , successor_(static_cast<Successor&&>(successor)) {}
+    , successor_(static_cast<Successor&&>(successor))
+    , returnAddress_(returnAddress) {}
 
   friend constexpr blocking_kind tag_invoke(tag_t<blocking>, const type& self) {
     blocking_kind pred = blocking(self.predecessor_);
@@ -311,6 +312,11 @@ struct _sndr<Predecessor, Successor>::type {
     return std::max(pred(), std::min(succ(), blocking_kind::maybe()));
   }
 
+  friend instruction_ptr
+  tag_invoke(tag_t<get_return_address>, const type& t) noexcept {
+    return t.returnAddress_;
+  }
+
   template(typename Receiver, typename Sender)  //
       (requires same_as<remove_cvref_t<Sender>, type> AND
            constructible_from<Successor, member_t<Sender, Successor>> AND
@@ -338,84 +344,123 @@ struct _sndr<Predecessor, Successor>::type {
 private:
   UNIFEX_NO_UNIQUE_ADDRESS Predecessor predecessor_;
   UNIFEX_NO_UNIQUE_ADDRESS Successor successor_;
+  instruction_ptr returnAddress_;
 };
 
 namespace _cpo {
 struct _fn {
-  // Sequencing a single sender is just the same as returning the sender
-  // itself.
-  template <typename First>
-  remove_cvref_t<First> operator()(First&& first) const
-      noexcept(std::is_nothrow_constructible_v<remove_cvref_t<First>, First>) {
-    return static_cast<First&&>(first);
-  }
+private:
+  struct _impl_fn {
+    // Sequencing a single sender is just the same as returning the sender
+    // itself.
+    template <typename First>
+    remove_cvref_t<First> operator()(instruction_ptr, First&& first) const
+        noexcept(
+            std::is_nothrow_constructible_v<remove_cvref_t<First>, First>) {
+      return static_cast<First&&>(first);
+    }
 
-  template(typename First, typename Second)  //
-      (requires sender<First> AND sender<Second> AND
-           tag_invocable<_fn, First, Second>)  //
-      auto
-      operator()(First&& first, Second&& second) const
-      noexcept(is_nothrow_tag_invocable_v<_fn, First, Second>)
-          -> tag_invoke_result_t<_fn, First, Second> {
-    return unifex::tag_invoke(
-        _fn{}, static_cast<First&&>(first), static_cast<Second&&>(second));
-  }
+    template(typename First, typename Second)  //
+        (requires sender<First> AND sender<Second> AND
+             tag_invocable<_fn, First, Second>)  //
+        auto
+        operator()(instruction_ptr, First&& first, Second&& second) const
+        noexcept(is_nothrow_tag_invocable_v<_fn, First, Second>)
+            -> tag_invoke_result_t<_fn, First, Second> {
+      return unifex::tag_invoke(
+          _fn{}, static_cast<First&&>(first), static_cast<Second&&>(second));
+    }
 
-  template(typename First, typename Second)  //
-      (requires sender<First> AND
-           sender<Second> AND(!tag_invocable<_fn, First, Second>))  //
-      auto
-      operator()(First&& first, Second&& second) const
-      noexcept(std::is_nothrow_constructible_v<
-               _seq::_sender<First, Second>,
-               First,
-               Second>) -> _seq::_sender<First, Second> {
-    return _seq::_sender<First, Second>{
-        static_cast<First&&>(first), static_cast<Second&&>(second)};
-  }
+    template(typename First, typename Second)  //
+        (requires sender<First> AND
+             sender<Second> AND(!tag_invocable<_fn, First, Second>))  //
+        auto
+        operator()(
+            instruction_ptr returnAddress, First&& first, Second&& second) const
+        noexcept(std::is_nothrow_constructible_v<
+                 _seq::_sender<First, Second>,
+                 First,
+                 Second,
+                 instruction_ptr>) -> _seq::_sender<First, Second> {
+      return _seq::_sender<First, Second>{
+          static_cast<First&&>(first),
+          static_cast<Second&&>(second),
+          returnAddress};
+    }
 
-  template(
-      typename First, typename Second, typename Third, typename... Rest)  //
-      (requires sender<First> AND sender<Second> AND
-           sender<Third> AND(sender<Rest>&&...)
-               AND tag_invocable<_fn, First, Second, Third, Rest...>)  //
-      auto
-      operator()(
-          First&& first, Second&& second, Third&& third, Rest&&... rest) const
-      noexcept(is_nothrow_tag_invocable_v<_fn, First, Second, Third, Rest...>)
-          -> tag_invoke_result_t<_fn, First, Second, Third, Rest...> {
-    return unifex::tag_invoke(
-        _fn{},
-        static_cast<First&&>(first),
-        static_cast<Second&&>(second),
-        static_cast<Third&&>(third),
-        static_cast<Rest&&>(rest)...);
-  }
+    template(
+        typename First, typename Second, typename Third, typename... Rest)  //
+        (requires sender<First> AND sender<Second> AND
+             sender<Third> AND(sender<Rest>&&...)
+                 AND tag_invocable<_fn, First, Second, Third, Rest...>)  //
+        auto
+        operator()(
+            instruction_ptr,
+            First&& first,
+            Second&& second,
+            Third&& third,
+            Rest&&... rest) const
+        noexcept(is_nothrow_tag_invocable_v<_fn, First, Second, Third, Rest...>)
+            -> tag_invoke_result_t<_fn, First, Second, Third, Rest...> {
+      return unifex::tag_invoke(
+          _fn{},
+          static_cast<First&&>(first),
+          static_cast<Second&&>(second),
+          static_cast<Third&&>(third),
+          static_cast<Rest&&>(rest)...);
+    }
 
-  template(
-      typename First, typename Second, typename Third, typename... Rest)  //
-      (requires sender<First> AND sender<Second> AND
-           sender<Third> AND(sender<Rest>&&...)
-               AND(!tag_invocable<_fn, First, Second, Third, Rest...>))  //
-      auto
-      operator()(First&& first, Second&& second, Third&& third, Rest&&... rest)
-          const noexcept(
-              std::is_nothrow_invocable_v<_fn, First, Second> &&
-              std::is_nothrow_invocable_v<
-                  _fn,
-                  std::invoke_result_t<_fn, First, Second>,
-                  Third,
-                  Rest...>)
-              -> std::invoke_result_t<
-                  _fn,
-                  std::invoke_result_t<_fn, First, Second>,
-                  Third,
-                  Rest...> {
-    // Fall-back to pair-wise invocation of the sequence() CPO.
-    return (*this)(
-        (*this)(static_cast<First&&>(first), static_cast<Second&&>(second)),
-        static_cast<Third&&>(third),
-        static_cast<Rest&&>(rest)...);
+    template(
+        typename First, typename Second, typename Third, typename... Rest)  //
+        (requires sender<First> AND sender<Second> AND
+             sender<Third> AND(sender<Rest>&&...)
+                 AND(!tag_invocable<_fn, First, Second, Third, Rest...>))  //
+        auto
+        operator()(
+            instruction_ptr returnAddress,
+            First&& first,
+            Second&& second,
+            Third&& third,
+            Rest&&... rest) const
+        noexcept(
+            std::is_nothrow_invocable_v<
+                _impl_fn,
+                instruction_ptr,
+                First,
+                Second> &&
+            std::is_nothrow_invocable_v<
+                _impl_fn,
+                instruction_ptr,
+                std::invoke_result_t<_fn, First, Second>,
+                Third,
+                Rest...>)
+            -> std::invoke_result_t<
+                _impl_fn,
+                instruction_ptr,
+                std::invoke_result_t<_fn, First, Second>,
+                Third,
+                Rest...> {
+      // Fall-back to pair-wise invocation of the sequence() CPO.
+      return (*this)(
+          returnAddress,
+          (*this)(
+              returnAddress,
+              static_cast<First&&>(first),
+              static_cast<Second&&>(second)),
+          static_cast<Third&&>(third),
+          static_cast<Rest&&>(rest)...);
+    }
+  };
+
+public:
+  template <typename First, typename... Rest>
+  auto operator()(First&& first, Rest&&... rest) const noexcept(
+      std::is_nothrow_invocable_v<_impl_fn, instruction_ptr, First, Rest...>)
+      -> std::invoke_result_t<_impl_fn, instruction_ptr, First, Rest...> {
+    return _impl_fn{}(
+        instruction_ptr::read_return_address(),
+        std::forward<First>(first),
+        std::forward<Rest>(rest)...);
   }
 };
 }  // namespace _cpo
diff --git a/include/unifex/then.hpp b/include/unifex/then.hpp
index 1570bc27..85e338f2 100644
--- a/include/unifex/then.hpp
+++ b/include/unifex/then.hpp
@@ -63,31 +63,31 @@ struct _receiver<Receiver, Func>::type {
   void set_value(Values&&... values) && noexcept {
     using result_type = std::invoke_result_t<Func, Values...>;
     if constexpr (std::is_void_v<result_type>) {
-      if constexpr (noexcept(std::invoke((Func&&)func_, (Values&&)values...))) {
-        std::invoke((Func&&)func_, (Values&&)values...);
-        unifex::set_value((Receiver&&)receiver_);
+      if constexpr (std::is_nothrow_invocable_v<Func, Values...>) {
+        std::invoke(std::move(func_), std::forward<Values>(values)...);
+        unifex::set_value(std::move(receiver_));
       } else {
         UNIFEX_TRY {
-          std::invoke((Func&&)func_, (Values&&)values...);
-          unifex::set_value((Receiver&&)receiver_);
+          std::invoke(std::move(func_), std::forward<Values>(values)...);
+          unifex::set_value(std::move(receiver_));
         }
         UNIFEX_CATCH(...) {
-          unifex::set_error((Receiver&&)receiver_, std::current_exception());
+          unifex::set_error(std::move(receiver_), std::current_exception());
         }
       }
     } else {
-      if constexpr (noexcept(std::invoke((Func&&)func_, (Values&&)values...))) {
+      if constexpr (std::is_nothrow_invocable_v<Func, Values...>) {
         unifex::set_value(
-            (Receiver&&)receiver_,
-            std::invoke((Func&&)func_, (Values&&)values...));
+            std::move(receiver_),
+            std::invoke(std::move(func_), std::forward<Values>(values)...));
       } else {
         UNIFEX_TRY {
           unifex::set_value(
-              (Receiver&&)receiver_,
-              std::invoke((Func&&)func_, (Values&&)values...));
+              std::move(receiver_),
+              std::invoke(std::move(func_), std::forward<Values>(values)...));
         }
         UNIFEX_CATCH(...) {
-          unifex::set_error((Receiver&&)receiver_, std::current_exception());
+          unifex::set_error(std::move(receiver_), std::current_exception());
         }
       }
     }
@@ -95,10 +95,10 @@ struct _receiver<Receiver, Func>::type {
 
   template <typename Error>
   void set_error(Error&& error) && noexcept {
-    unifex::set_error((Receiver&&)receiver_, (Error&&)error);
+    unifex::set_error(std::move(receiver_), std::forward<Error>(error));
   }
 
-  void set_done() && noexcept { unifex::set_done((Receiver&&)receiver_); }
+  void set_done() && noexcept { unifex::set_done(std::move(receiver_)); }
 
   template(typename CPO, typename R)                                //
       (requires is_receiver_query_cpo_v<CPO> AND same_as<R, type>)  //
@@ -129,6 +129,7 @@ template <typename Predecessor, typename Func>
 struct _sender<Predecessor, Func>::type {
   UNIFEX_NO_UNIQUE_ADDRESS Predecessor pred_;
   UNIFEX_NO_UNIQUE_ADDRESS Func func_;
+  instruction_ptr returnAddress_;
 
 private:
   // This helper transforms an argument list into either
@@ -179,52 +180,81 @@ struct _sender<Predecessor, Func>::type {
               member_t<Sender, Predecessor>,
               receiver_t<remove_cvref_t<Receiver>>> {
     return unifex::connect(
-        static_cast<Sender&&>(s).pred_,
+        std::forward<Sender>(s).pred_,
         receiver_t<remove_cvref_t<Receiver>>{
-            static_cast<Sender&&>(s).func_, static_cast<Receiver&&>(r)});
+            std::forward<Sender>(s).func_, std::forward<Receiver>(r)});
   }
 
   friend constexpr blocking_kind
   tag_invoke(tag_t<unifex::blocking>, const type& self) noexcept {
     return unifex::blocking(self.pred_);
   }
+
+  friend instruction_ptr
+  tag_invoke(tag_t<get_return_address>, const type& t) noexcept {
+    return t.returnAddress_;
+  }
 };
 
 namespace _cpo {
 struct _fn {
 private:
-  template <typename Sender, typename Func>
-  using _result_t = typename conditional_t<
-      tag_invocable<_fn, Sender, Func>,
-      meta_tag_invoke_result<_fn>,
-      meta_quote2<_then::sender>>::template apply<Sender, Func>;
+  struct _impl_fn {
+    template(typename Sender, typename Func)         //
+        (requires tag_invocable<_fn, Sender, Func>)  //
+        auto
+        operator()(Sender&& predecessor, Func&& func, instruction_ptr) const
+        noexcept(is_nothrow_tag_invocable_v<_fn, Sender, Func>)
+            -> tag_invoke_result_t<_fn, Sender, Func> {
+      return unifex::tag_invoke(
+          _fn{}, std::forward<Sender>(predecessor), std::forward<Func>(func));
+    }
+
+    template(typename Sender, typename Func)           //
+        (requires(!tag_invocable<_fn, Sender, Func>))  //
+        auto
+        operator()(
+            Sender&& predecessor,
+            Func&& func,
+            instruction_ptr returnAddress) const
+        noexcept(std::is_nothrow_constructible_v<
+                 _then::sender<Sender, Func>,
+                 Sender,
+                 Func,
+                 instruction_ptr>) -> _then::sender<Sender, Func> {
+      return _then::sender<Sender, Func>{
+          std::forward<Sender>(predecessor),
+          std::forward<Func>(func),
+          returnAddress};
+    }
+  };
 
 public:
-  template(typename Sender, typename Func)         //
-      (requires tag_invocable<_fn, Sender, Func>)  //
-      auto
-      operator()(Sender&& predecessor, Func&& func) const
-      noexcept(is_nothrow_tag_invocable_v<_fn, Sender, Func>)
-          -> _result_t<Sender, Func> {
-    return unifex::tag_invoke(_fn{}, (Sender&&)predecessor, (Func&&)func);
-  }
-  template(typename Sender, typename Func)           //
-      (requires(!tag_invocable<_fn, Sender, Func>))  //
-      auto
-      operator()(Sender&& predecessor, Func&& func) const
-      noexcept(std::is_nothrow_constructible_v<
-               _then::sender<Sender, Func>,
-               Sender,
-               Func>) -> _result_t<Sender, Func> {
-    return _then::sender<Sender, Func>{(Sender&&)predecessor, (Func&&)func};
+  template <typename Sender, typename Func>
+  auto operator()(Sender&& predecessor, Func&& func) const noexcept(
+      std::is_nothrow_invocable_v<_impl_fn, Sender, Func, instruction_ptr>)
+      -> std::invoke_result_t<_impl_fn, Sender, Func, instruction_ptr> {
+    return _impl_fn{}(
+        std::forward<Sender>(predecessor),
+        std::forward<Func>(func),
+        instruction_ptr::read_return_address());
   }
+
   template <typename Func>
   constexpr auto operator()(Func&& func) const
-      noexcept(std::is_nothrow_invocable_v<tag_t<bind_back>, _fn, Func>)
-          -> bind_back_result_t<_fn, Func> {
-    return bind_back(*this, (Func&&)func);
+      noexcept(std::is_nothrow_invocable_v<
+               tag_t<bind_back>,
+               _impl_fn,
+               Func,
+               instruction_ptr>)
+          -> bind_back_result_t<_impl_fn, Func, instruction_ptr> {
+    return bind_back(
+        _impl_fn{},
+        std::forward<Func>(func),
+        instruction_ptr::read_return_address());
   }
 };
+
 }  // namespace _cpo
 }  // namespace _then
 
diff --git a/include/unifex/with_query_value.hpp b/include/unifex/with_query_value.hpp
index da386685..8234e14c 100644
--- a/include/unifex/with_query_value.hpp
+++ b/include/unifex/with_query_value.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * Licensed under the Apache License Version 2.0 with LLVM Exceptions
  * (the "License"); you may not use this file except in compliance with
@@ -142,9 +142,10 @@ class _sender<CPO, Value, Sender>::type {
       sender_traits<Sender>::is_always_scheduler_affine;
 
   template <typename Sender2, typename Value2>
-  explicit type(Sender2&& sender, Value2&& value)
+  explicit type(Sender2&& sender, Value2&& value, instruction_ptr returnAddress)
     : sender_((Sender2 &&) sender)
-    , value_((Value2 &&) value) {}
+    , value_((Value2 &&) value)
+    , returnAddress_(returnAddress) {}
 
   template(typename Self, typename Receiver)  //
       (requires same_as<remove_cvref_t<Self>, type> AND
@@ -181,28 +182,58 @@ class _sender<CPO, Value, Sender>::type {
     return unifex::blocking(s.sender_);
   }
 
+  friend instruction_ptr
+  tag_invoke(tag_t<get_return_address>, const type& t) noexcept {
+    return t.returnAddress_;
+  }
+
 private:
   Sender sender_;
   Value value_;
+  instruction_ptr returnAddress_;
 };
 }  // namespace _with_query_value
 
 namespace _with_query_value_cpo {
 inline const struct _fn {
+  struct _impl_fn {
+    template <typename Sender, typename CPO, typename Value>
+    _with_query_value::sender<CPO, Value, Sender> operator()(
+        Sender&& sender,
+        CPO,
+        Value&& value,
+        instruction_ptr returnAddress) const {
+      static_assert(
+          std::is_empty_v<CPO>,
+          "with_query_value() does not support stateful CPOs");
+      return _with_query_value::sender<CPO, Value, Sender>{
+          (Sender&&)sender, (Value&&)value, returnAddress};
+    }
+  };
+
   template <typename Sender, typename CPO, typename Value>
-  _with_query_value::sender<CPO, Value, Sender>
-  operator()(Sender&& sender, CPO, Value&& value) const {
-    static_assert(
-        std::is_empty_v<CPO>,
-        "with_query_value() does not support stateful CPOs");
-    return _with_query_value::sender<CPO, Value, Sender>{
-        (Sender &&) sender, (Value &&) value};
+  auto operator()(Sender&& sender, CPO cpo, Value&& value) const {
+    return _impl_fn{}(
+        std::forward<Sender>(sender),
+        std::forward<CPO>(cpo),
+        std::forward<Value>(value),
+        instruction_ptr::read_return_address());
   }
+
   template <typename CPO, typename Value>
   constexpr auto operator()(const CPO&, Value&& value) const
-      noexcept(std::is_nothrow_invocable_v<tag_t<bind_back>, _fn, CPO, Value>)
-          -> bind_back_result_t<_fn, CPO, Value> {
-    return bind_back(*this, CPO{}, (Value &&) value);
+      noexcept(std::is_nothrow_invocable_v<
+               tag_t<bind_back>,
+               _fn,
+               CPO,
+               Value,
+               instruction_ptr>)
+          -> bind_back_result_t<_impl_fn, CPO, Value, instruction_ptr> {
+    return bind_back(
+        _impl_fn{},
+        CPO{},
+        (Value&&)value,
+        instruction_ptr::read_return_address());
   }
 } with_query_value{};
 }  // namespace _with_query_value_cpo