         return result
     }
     
-    @_transparent
-    @discardableResult
-    private mutating func _fetchStore(_ new: AtomicBase<Instance>) -> AtomicBase<Instance> {
-        let _new = Unmanaged.passRetained(new)
-        let result = withUnsafeMutablePointer(to: &base) { $0.withMemoryRebound(to: Optional<UnsafeMutableRawPointer>.self, capacity: 1) { _AtomicExchangePtrBarrier(_new.toOpaque(), $0) } }
-        let _old = Unmanaged<AtomicBase<Instance>>.fromOpaque(UnsafeRawPointer(result!))
-        return _old.takeRetainedValue()
+    @inline(never)
+    @discardableResult
+    private mutating func _fetchStore(_ new: Base) -> Base {
+        return withBasePointer { Unmanaged<Base>.fromOpaque(UnsafeRawPointer(_AtomicExchangePtrBarrier(Unmanaged.passRetained(new).toOpaque(), $0))).takeRetainedValue() }
     }
 }
 

    
    /// Atomic fetch the current value.
    public mutating func fetchSelf() -> (current: Atomic, value: Instance) {
        defer { _fixLifetime(base) }
        let _base = _fetch()
        return (Atomic(base: _base), _base.value)
    }
    
    /// Compare and set the value.
    public mutating func compareSet(old: Atomic, new: Instance) -> Bool {
        return self._compareSet(old: old.base, new: AtomicBase(value: new))
    }
    
    /// Set the value, and returns the previous value.
    public mutating func fetchStore(_ new: Instance) -> Instance {
        defer { _fixLifetime(base) }
        return _fetchStore(AtomicBase(value: new)).value
    }
    
    /// Set the value.
    @discardableResult
    public mutating func fetchStore(block: (Instance) throws -> Instance) rethrows -> Instance {
        let new = AtomicBase<Instance>()
        while true {
            let old = self.base
            new.value = try block(old.value)
            if self._compareSetWeak(old: old, new: new) {
                return old.value
            }
        }
    }

    }
    
    /// Set the value, and returns the previous value. `block` is called repeatedly until result accepted.
    @_inlineable
    @discardableResult
    public mutating func fetchStore(block: (Atom) throws -> Atom) rethrows -> Atom {
        while true {
            let (old, oldVal) = self.fetchSelf()
