diff --git a/arkoala-arkts/arkui/src/LazyForEach.ts b/arkoala-arkts/arkui/src/LazyForEach.ts
index 045a076c52198c1be89a0ff34b7514721ab7f61e..8dc2bb02e047296f1c1a263df49d6f51f9eec00d 100644
--- a/arkoala-arkts/arkui/src/LazyForEach.ts
+++ b/arkoala-arkts/arkui/src/LazyForEach.ts
@@ -13,9 +13,9 @@
  * limitations under the License.
  */
 
-import { __context, contextNode, memoEntry2, remember, rememberMutableState, scheduleCallback } from "@koalaui/runtime"
+import { __context, __id, contextNode, memo, memoEntry2, remember, rememberMutableState, scheduleCallback } from "@koalaui/runtime"
 import { hashCodeFromString, int32 } from "@koalaui/common"
-import { nullptr, pointer } from "@koalaui/interop";
+import { InteropNativeModule, nullptr, pointer } from "@koalaui/interop";
 import { PeerNode } from "./generated/PeerNode";
 import { LazyForEachOps } from "./generated/ArkLazyForEachOpsMaterialized"
 
@@ -53,9 +53,16 @@ class LazyForEachManager {
      // Special pointer to mark that more elements needed.
     static specialPointer: pointer = 1
     static OnRangeUpdate(parent: pointer, totalCount: int32, updater: (currentIndex: int32, currentMark: pointer) => void) {
-        if (LazyForEachManager.isDummy)
-            scheduleCallback(() =>  updater(0, LazyForEachManager.specialPointer))
+        if (LazyForEachManager.isDummy) {
+			console.log(`update to 50`)
+            scheduleCallback(() =>  updater(50, 0xfff))
+}
         else
+        //     scheduleCallback(() => 
+        // {updater(10, 0xfff)
+        //     console.log("update markItem to 0xf")
+
+        // })
             LazyForEachOps.OnRangeUpdate(parent, totalCount, updater)
     }
 
@@ -77,33 +84,6 @@ class LazyForEachManager {
     }
 }
 
-class VisibleRange {
-    parent: pointer = nullptr
-    markUp: pointer = nullptr
-    markDown: pointer = nullptr
-    indexUp: int32
-    indexDown: int32
-
-    constructor(parent: PeerNode, indexUp: int32, indexDown: int32) {
-        this.parent = parent.peer.ptr
-        this.indexUp = indexUp
-        this.indexDown = indexDown
-    }
-    needFillUp(): boolean {
-        let more = LazyForEachManager.NeedMoreElements(this.parent, this.markUp, 0)
-        if (more == nullptr) return false
-        this.markUp = more
-        return true
-    }
-
-    needFillDown(): boolean {
-        let more = LazyForEachManager.NeedMoreElements(this.parent, this.markDown, 1)
-        if (more == nullptr) return false
-        this.markDown = more
-        return true
-    }
-}
-
 /** @memo */
 export function LazyForEach<T>(dataSource: IDataSource<T>,
     /** @memo */
@@ -114,11 +94,11 @@ export function LazyForEach<T>(dataSource: IDataSource<T>,
     let mark = rememberMutableState<pointer>(nullptr)
 	let version = rememberMutableState<int32>(0)
 	console.log(`LazyForEach current=${current.value} version=${version.value} mark=${mark.value}`)
-
     let parent = contextNode<PeerNode>()
-    const visibleRange = new VisibleRange(parent, current.value, current.value)
+    let parentPtr = parent.peer.ptr
+
     remember(() => {
-        LazyForEachManager.OnRangeUpdate(visibleRange.parent, dataSource.totalCount() as int32, (currentIndex: int32, currentMark: pointer) => {
+        LazyForEachManager.OnRangeUpdate(parentPtr, dataSource.totalCount() as int32, (currentIndex: int32, currentMark: pointer) => {
             console.log(`LazyForEach[${parent}]: current updated to ${currentIndex} ${currentMark}`)
             current.value = currentIndex
             mark.value = currentMark
@@ -127,9 +107,33 @@ export function LazyForEach<T>(dataSource: IDataSource<T>,
     })
     // Subscribe to version changes.
     version.value
+    let markUp = mark.value
+    let markDown = mark.value
+	// /* @memo:intrinsic */
+    // const scope = __context().scope(__id())
+	// console.log(`LazyForEach[${parent}]: scope unchanged = ${scope.unchanged}`)
+    const needFillUp = memo(() => () => {
+		version.value
+        console.log(`LazyForEach[${parent}]: needFillUp, markUp = ${markUp}`)
+        let more = LazyForEachManager.NeedMoreElements(parentPtr, markUp, 0)
+        if (more == nullptr) return false
+        markUp = more
+        return true
+    })
+    const needFillDown = memo(() => () => {
+		version.value
+        console.log(`LazyForEach[${parent}]: needFillDown, markDown = ${markDown}`)
+        let more = LazyForEachManager.NeedMoreElements(parentPtr, markDown, 1)
+        if (more == nullptr) return false
+        markDown = more
+        return true
+    })
+
+    let indexUp = current.value
+    let indexDown = current.value
 
     let generator = (element: T, index: number): int32 => keyGenerator ? hashCodeFromString(keyGenerator!(element, index)) : index as int32
-    let index: number = visibleRange.indexUp as number
+    let index: number = indexUp as number
     LazyForEachManager.SetInsertMark(parent, mark.value, false)
 	while (true) {
         console.log(`LazyForEach[${parent}]: index=${index}`)
@@ -142,16 +146,16 @@ export function LazyForEach<T>(dataSource: IDataSource<T>,
 	        element,
             index
 	    )
-        let moreUp = visibleRange.needFillUp()
-        if (moreUp && visibleRange.indexUp > 0) {
-            index = --visibleRange.indexUp
-        } else if (visibleRange.needFillDown()) {
-            index = ++visibleRange.indexDown
+        let moreUp = needFillUp()
+        if (moreUp && indexUp > 0) {
+            index = --indexUp
+        } else if (needFillDown()) {
+            index = ++indexDown
         } else {
             console.log("No more needed")
             index = -1
         }
-        LazyForEachManager.SetInsertMark(parent, moreUp ? visibleRange.markUp : visibleRange.markDown, moreUp)
+        LazyForEachManager.SetInsertMark(parent, moreUp ? markUp : markDown, moreUp)
 	}
 	parent.setInsertMark(nullptr, false)
 }