diff --git a/.idea/artifacts/netchdf_0_6_0.xml b/.idea/artifacts/netchdf_0_6_0.xml
new file mode 100644
index 00000000..ff6f8fd0
--- /dev/null
+++ b/.idea/artifacts/netchdf_0_6_0.xml
@@ -0,0 +1,8 @@
+<component name="ArtifactManager">
+  <artifact type="jar" name="netchdf-0.6.0">
+    <output-path>$PROJECT_DIR$/core/build/libs</output-path>
+    <root id="archive" name="netchdf-0.6.0.jar">
+      <element id="module-output" name="netchdf.core.jvmMain" />
+    </root>
+  </artifact>
+</component>
\ No newline at end of file
diff --git a/.idea/artifacts/netchdf_0_7_0.xml b/.idea/artifacts/netchdf_0_7_0.xml
new file mode 100644
index 00000000..bacc1f70
--- /dev/null
+++ b/.idea/artifacts/netchdf_0_7_0.xml
@@ -0,0 +1,8 @@
+<component name="ArtifactManager">
+  <artifact type="jar" name="netchdf-0.7.0">
+    <output-path>$PROJECT_DIR$/core/build/libs</output-path>
+    <root id="archive" name="netchdf-0.7.0.jar">
+      <element id="module-output" name="netchdf.core.jvmMain" />
+    </root>
+  </artifact>
+</component>
\ No newline at end of file
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 80212702..2966a19c 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -9,7 +9,6 @@
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/cli" />
             <option value="$PROJECT_DIR$/core" />
             <option value="$PROJECT_DIR$/testclibs" />
             <option value="$PROJECT_DIR$/testfiles" />
diff --git a/Readme.md b/Readme.md
index cb0faaf0..9b66c613 100644
--- a/Readme.md
+++ b/Readme.md
@@ -59,10 +59,10 @@ Also see:
 We use the latest LTS (long term support) Java version, and will not be explicitly supporting older versions.
 Currently that is Java 21.
 
-We also use the latest stable version of Kotlin that is compatible with the Java version. Currently that is Kotlin 2.1.
+We also use the latest stable version of Kotlin that is compatible with the Java version. Currently that is Kotlin 2.1.21.
 
 Gradle is our build system. We will use the latest stable version of Gradle compatible with our Java and Kotlin versions.
-Currently that is Gradle 8.14.
+Currently that is Gradle 8.14.3.
 
 For now, you must download and build the library yourself. Eventually we will publish it to Maven Central.
 The IntelliJ IDE is highly recommended for all JVM development.
@@ -265,7 +265,7 @@ For example, a Variable of datatype Float will return an ArrayFloat, which is Ar
     return data as ArrayUByte. 
   * Netcdf-4 encodes CHAR values as HDF5 string type with elemSize = 1, so we use that convention to detect 
     legacy CHAR variables in HDF5 format. (NC_CHAR should not be used in new Netcdf-4 files, use NC_UBYTE or NC_STRING.) 
-    Variables of type CHAR return data as STRING, since users can use UBYTE if thats what they intend.
+    Variables of type CHAR return data as STRING, since users can use UBYTE if that's what they intend.
   * Netcdf-4/HDF5 String variables may be fixed or variable length. For fixed Strings, we set the size of Datatype.STRING to 
     the fixed size. For both fixed and variable length Strings, the string will be truncated at the first zero byte, if any.
   * HDF4 does not have a STRING type, but does have signed and unsigned CHAR, and signed and unsigned BYTE. 
@@ -318,7 +318,7 @@ isNetcdf4 = true.
     1.  If a group or variable has an attribute with name "_NCProperties", "_Netcdf4Coordinates", "_Netcdf4Dimid" or "_nc3_strict".
     2.  If a variable name starts with "_nc4_non_coord_".
     3.  If a variable has an attrinute named "DIMENSION_LIST with type vlen of reference.
-    4.  If a dimenson name starts with "This is a netCDF dimension but not a netCDF variable"
+    4.  If a dimension name starts with "This is a netCDF dimension but not a netCDF variable"
 
 Other than trying to identify which library wrote the file, Netchdf does not do any special processing for Netcdf4 files,
 except:
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index e7fc1c9a..72664641 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -9,7 +9,6 @@ version = libs.versions.netchdf.get()
 kotlin {
     jvm()
 
-    /*
     val hostOs = System.getProperty("os.name")
     val arch = System.getProperty("os.arch")
     when {
@@ -29,8 +28,6 @@ kotlin {
         else -> throw GradleException("Host OS is not supported.")
     }
 
-     */
-
     sourceSets {
         val commonMain by getting {
             dependencies {
diff --git a/core/src/commonMain/kotlin/com/sunya/cdm/api/Dimension.kt b/core/src/commonMain/kotlin/com/sunya/cdm/api/Dimension.kt
index f7613a62..68434234 100644
--- a/core/src/commonMain/kotlin/com/sunya/cdm/api/Dimension.kt
+++ b/core/src/commonMain/kotlin/com/sunya/cdm/api/Dimension.kt
@@ -12,10 +12,9 @@ data class Dimension(val orgName : String, val length : Long, val isShared : Boo
     constructor(len : Int) : this("", len.toLong(), false)
     constructor(len : Long) : this("", len, false)
 
-    // orgName may be different
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
-        if (javaClass != other?.javaClass) return false
+        if (other == null || this::class != other::class) return false
 
         other as Dimension
 
@@ -33,5 +32,4 @@ data class Dimension(val orgName : String, val length : Long, val isShared : Boo
         return result
     }
 
-
 }
\ No newline at end of file
diff --git a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/BTree2.kt b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/BTree2.kt
index 013976fc..12fed42b 100644
--- a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/BTree2.kt
+++ b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/BTree2.kt
@@ -210,7 +210,9 @@ fun getSizeOfNumberOfRecords(
 
 // jhdf
 internal fun bytesNeededToHoldNumber(number: Int): Int {
-    return (Integer.numberOfTrailingZeros(Integer.highestOneBit(number)) + 8) / 8
+    //     return (Integer.numberOfTrailingZeros(Integer.highestOneBit(number)) + 8) / 8
+    val p1 = number.takeHighestOneBit()
+    return (p1.countTrailingZeroBits() + 8) / 8
 }
 
 /* private fun getSizeOfTotalNumberOfChildRecords(nodeSize: Int, depth: Int, recordSize: Int): Int {
diff --git a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/BTree2data.kt b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/BTree2data.kt
index 68ccfb51..e30db2b7 100644
--- a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/BTree2data.kt
+++ b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/BTree2data.kt
@@ -63,6 +63,8 @@ internal class BTree2data(
         }
     }
 
+    fun countChunks() = asSequence().count()
+
     fun chunkIterator(): Iterator<DataChunk> = asSequence().iterator()
 
     internal fun findDataChunk(order: Int): DataChunk? {
diff --git a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/ExtensibleArrayIndex.kt b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/ExtensibleArrayIndex.kt
index af023226..6eb96443 100644
--- a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/ExtensibleArrayIndex.kt
+++ b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/ExtensibleArrayIndex.kt
@@ -5,7 +5,6 @@ package com.sunya.netchdf.hdf5
 import com.sunya.cdm.api.computeSize
 import com.sunya.cdm.iosp.OpenFileState
 import com.sunya.cdm.util.InternalLibraryApi
-import java.util.*
 
 // DataLayoutExtensibleArray4
 class ExtensibleArrayIndex(val h5: H5builder, address: Long, datasetDimensions: IntArray, chunkDimensions: IntArray) {
diff --git a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/FractalHeap.kt b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/FractalHeap.kt
index 01e595f8..f89f4396 100644
--- a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/FractalHeap.kt
+++ b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/FractalHeap.kt
@@ -7,6 +7,8 @@ import com.sunya.cdm.iosp.OpenFileIF
 import com.sunya.cdm.iosp.OpenFileState
 import com.sunya.cdm.util.*
 
+val UNDEFINED_ADDRESS = -1L
+
 /** Level 1G - Fractal Heap  */
 // TODO rewrite
 internal class FractalHeap(private val h5: H5builder, forWho: String, address: Long) {
diff --git a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/H5readChunkedConcurrent.kt b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/H5readChunkedConcurrent.kt
index a4cf9586..79f36f29 100644
--- a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/H5readChunkedConcurrent.kt
+++ b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/H5readChunkedConcurrent.kt
@@ -18,6 +18,7 @@ import com.sunya.cdm.util.InternalLibraryApi
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.channels.ReceiveChannel
 import kotlinx.coroutines.channels.produce
@@ -44,14 +45,38 @@ class H5readChunkedConcurrent<T>(val h5: H5builder, val v2: Variable<T>, wantSec
         if (vinfo.mdl is DataLayoutBTreeVer1) {
             val mdl = vinfo.mdl
             chunks = BTree1data(rafext, mdl.btreeAddress, varShape, mdl.chunkDims.toLongArray())
+            println(" BTree1data nchunks = ${chunks.countChunks()}")
         } else if (vinfo.mdl is DataLayoutBtreeVer2) {
             chunks = BTree2data(rafext, v2.name, vinfo.dataPos, v2.shape, vinfo.storageDims)
+            println(" BTree2data nchunks = ${chunks.countChunks()}")
         } else {
-            throw RuntimeException("H5chunkConcurrent cant read ${vinfo.mdl.javaClass.simpleName}")
+            throw RuntimeException("H5chunkConcurrent cant read ${vinfo.mdl::class}")
         }
     }
 
+    // Start the backgroup threads then return immediately
+
     fun readChunks(nthreads: Int, lamda: (ArraySection<T>) -> Unit, done: () -> Unit) {
+        println(" readChunks with  nthreads = $nthreads")
+
+        GlobalScope.launch(Dispatchers.Default) {
+            val jobs = mutableListOf<Job>()
+            val workers = mutableListOf<Worker>()
+            val chunkProducer = produceChunks(chunks.asSequence())
+            repeat(nthreads) {
+                val worker = Worker()
+                jobs.add(launchJob(worker, chunkProducer, lamda))
+                workers.add(worker)
+            }
+
+            // wait for all jobs to be done, then close everything
+            joinAll(*jobs.toTypedArray())
+            workers.forEach { it.rafext.close() }
+            done()
+        }
+    }
+
+    fun readChunksBlocking(nthreads: Int, lamda: (ArraySection<T>) -> Unit, done: () -> Unit) {
 
         runBlocking {
             val jobs = mutableListOf<Job>()
diff --git a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/Hdf5File.kt b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/Hdf5File.kt
index 59c168fa..67cadbbd 100644
--- a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/Hdf5File.kt
+++ b/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/Hdf5File.kt
@@ -39,7 +39,7 @@ class Hdf5File(val filename : String, strict : Boolean = false) : Netchdf {
             return("DataContainerAttribute")
         }
         val vinfo = (v.spObject as DataContainerVariable)
-        return vinfo.mdl.javaClass.simpleName
+        return vinfo.mdl::class.simpleName ?: "none"
     }
 
     var useNThreads : Int? = null
@@ -166,10 +166,11 @@ class Hdf5File(val filename : String, strict : Boolean = false) : Netchdf {
         val deque = Deque<ArraySection<T>>(10)
 
         init {
+            // we start up the concurrent read, but its blocking here
             reader.readChunks(
                 nthreads,
                 lamda = { deque.add(it) },
-                done = { deque.done() }
+                done = { deque.complete() }
             )
         }
 
@@ -187,8 +188,7 @@ class Hdf5File(val filename : String, strict : Boolean = false) : Netchdf {
                                           wantSection: SectionPartial?, nthreads: Int?) {
         val reader = H5readChunkedConcurrent(header, v2, wantSection)
         val availableProcessors = this.useNThreads()
-        // println("availableProcessors = $availableProcessors")
-        reader.readChunks(nthreads ?: availableProcessors, lamda, done = { done() })
+        reader.readChunksBlocking(nthreads ?: availableProcessors, lamda, done)
     }
 
 }
\ No newline at end of file
diff --git a/core/src/commonMain/kotlin/com/sunya/netchdf/util/Kmp.kt b/core/src/commonMain/kotlin/com/sunya/netchdf/util/Kmp.kt
index df2f8a17..62cdc1d4 100644
--- a/core/src/commonMain/kotlin/com/sunya/netchdf/util/Kmp.kt
+++ b/core/src/commonMain/kotlin/com/sunya/netchdf/util/Kmp.kt
@@ -1,11 +1,10 @@
 package com.sunya.netchdf.util
 
-
 expect fun useDefaultNThreads(): Int
 
 // add to end, take from head
 expect class Deque<T>(initialCapacity: Int) {
     fun add(item: T)
     fun next(): T?
-    fun done()
+    fun complete()
 }
diff --git a/core/src/commonTest/kotlin/com/sunya/netchdf/hdf5/Btree1dataTest.kt b/core/src/commonTest/kotlin/com/sunya/netchdf/hdf5/Btree1dataTest.kt
index e45fab9f..d887759c 100644
--- a/core/src/commonTest/kotlin/com/sunya/netchdf/hdf5/Btree1dataTest.kt
+++ b/core/src/commonTest/kotlin/com/sunya/netchdf/hdf5/Btree1dataTest.kt
@@ -5,9 +5,7 @@ package com.sunya.netchdf.hdf5
 import com.sunya.cdm.api.ArraySection
 import com.sunya.cdm.api.toLongArray
 import com.sunya.cdm.util.InternalLibraryApi
-import com.sunya.netchdf.testutil.nano
 import com.sunya.netchdf.testutil.testData
-import kotlin.system.measureNanoTime
 import kotlin.test.Test
 
 class Btree1dataTest {
@@ -58,15 +56,15 @@ class Btree1dataTest {
             println("nthreads,   time in secs")
 
             for (nthreads in listOf(1, 2, 4, 8, 10, 16, 20, 24, 32, 40, 48)) {
-                val time = measureNanoTime {
+               // val time = measureNanoTime {
                     //     fun readChunks(nthreads: Int, lamda: (ArraySection<*>) -> Unit, done: () -> Unit) {
                     val reader = H5readChunkedConcurrent(myfile.header, myvar, null)
                     reader.readChunks(nthreads, lamda = { asect: ArraySection<*> ->
                         // println(" section = ${asect.chunkSection}")
                     }, { }, )
                 }
-                println("$nthreads, ${time * nano}")
-            }
+                //println("$nthreads, ${time * nano}")
+            //}
         }
     }
 
diff --git a/core/src/commonTest/kotlin/com/sunya/netchdf/hdf5/JhdfReadTest.kt b/core/src/commonTest/kotlin/com/sunya/netchdf/hdf5/JhdfReadTest.kt
index 4da8f966..d3e31381 100644
--- a/core/src/commonTest/kotlin/com/sunya/netchdf/hdf5/JhdfReadTest.kt
+++ b/core/src/commonTest/kotlin/com/sunya/netchdf/hdf5/JhdfReadTest.kt
@@ -7,7 +7,7 @@ import com.sunya.netchdf.testutil.testData
 
 class JhdfReadTest {
     companion object {
-        @JvmStatic
+        // @JvmStatic
         fun files(): Iterator<String> {
             return JhdfFiles.files()
         }
diff --git a/core/src/commonTest/kotlin/com/sunya/netchdf/testutil/TestFiles.kt b/core/src/commonTest/kotlin/com/sunya/netchdf/testutil/TestFiles.kt
index 7c904704..b942d78c 100644
--- a/core/src/commonTest/kotlin/com/sunya/netchdf/testutil/TestFiles.kt
+++ b/core/src/commonTest/kotlin/com/sunya/netchdf/testutil/TestFiles.kt
@@ -3,6 +3,7 @@ package com.sunya.netchdf.testutil
 import okio.FileSystem
 import okio.Path
 import okio.Path.Companion.toPath
+import okio.SYSTEM
 
 const val testData = "../core/src/commonTest/data/"
 
diff --git a/core/src/jvmMain/kotlin/com/sunya/netchdf/util/Kmp.kt b/core/src/jvmMain/kotlin/com/sunya/netchdf/util/Kmp.kt
index 1a86618a..c3eea2db 100644
--- a/core/src/jvmMain/kotlin/com/sunya/netchdf/util/Kmp.kt
+++ b/core/src/jvmMain/kotlin/com/sunya/netchdf/util/Kmp.kt
@@ -1,48 +1,51 @@
 package com.sunya.netchdf.util
 
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
 import java.lang.Runtime.*
 import java.util.concurrent.ConcurrentLinkedDeque
+import kotlin.RuntimeException
 
 // todo: i have 2 threads per processer, these dont help the IO i think.
 actual fun useDefaultNThreads(): Int {
     return getRuntime().availableProcessors() / 2
 }
 
+private const val debug = false
+
 actual class Deque<T> actual constructor(initialCapacity: Int) {
     val delegate = ConcurrentLinkedDeque<T>()
-    var done = false
+    var complete = false
 
     actual fun add(item: T) {
+        if (debug) println(" Deque add")
         delegate.add(item)
     }
 
-    //actual fun next(): T? {
-    //    return delegate.poll() // can i block until available ??
-    //}
-
     actual fun next(): T? {
+
         var countWaits = 0
-        while (true) {
-            val firstElement = delegate.poll()
+        while (countWaits < 1000) {
+            val firstElement = delegate.pollFirst()
             if (firstElement != null) {
+                if (debug) println(" Deque got element")
                 return firstElement
-            } else if (done) {
-                done()
-                return null
-            } else if (countWaits > 100) {
-                println("takes too long (10 sec)")
-                done()
+            } else if (complete) {
+                if (debug) println(" Deque complete")
                 return null
             } else {
-                // wait 100 msecs
-                Thread.sleep(100) // java only
+                if (debug) println(" Deque wait")
+                runBlocking {
+                    delay(10)
+                }
                 countWaits++
             }
         }
-
+        throw RuntimeException("Deque next timed out (10 sec)")
     }
 
-    actual fun done() {
-        done = true
+    actual fun complete() {
+        if (debug) println(" Deque complete was called")
+        complete = true
     }
 }
\ No newline at end of file
diff --git a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/FractalHeapJ.kt b/core/src/jvmTest/kotlin/com/sunya/netchdf/hdf5/FractalHeapJ.kt
similarity index 99%
rename from core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/FractalHeapJ.kt
rename to core/src/jvmTest/kotlin/com/sunya/netchdf/hdf5/FractalHeapJ.kt
index b986ee39..616831f3 100644
--- a/core/src/commonMain/kotlin/com/sunya/netchdf/hdf5/FractalHeapJ.kt
+++ b/core/src/jvmTest/kotlin/com/sunya/netchdf/hdf5/FractalHeapJ.kt
@@ -312,5 +312,5 @@ fun bytesNeededToHoldNumber(number: Long): Int {
     if (number == 0L) {
         return 1
     }
-    return ceil(java.math.BigInteger.valueOf(number).bitLength() / 8.0).toInt()
+    return ceil(BigInteger.valueOf(number).bitLength() / 8.0).toInt()
 }
\ No newline at end of file
diff --git a/core/src/jvmTest/kotlin/com/sunya/netchdf5/hdf5/TestBtree2size.kt b/core/src/jvmTest/kotlin/com/sunya/netchdf/hdf5/TestBtree2size.kt
similarity index 100%
rename from core/src/jvmTest/kotlin/com/sunya/netchdf5/hdf5/TestBtree2size.kt
rename to core/src/jvmTest/kotlin/com/sunya/netchdf/hdf5/TestBtree2size.kt
diff --git a/core/src/nativeMain/kotlin/com/sunya/netchdf/util/Kmp.kt b/core/src/nativeMain/kotlin/com/sunya/netchdf/util/Kmp.kt
index 2830305c..d2dbd080 100644
--- a/core/src/nativeMain/kotlin/com/sunya/netchdf/util/Kmp.kt
+++ b/core/src/nativeMain/kotlin/com/sunya/netchdf/util/Kmp.kt
@@ -1,24 +1,68 @@
 package com.sunya.netchdf.util
 
-actual fun getAvailableProcessors(): Int {
-    return Platform.availableProcessors() / 2
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlin.experimental.ExperimentalNativeApi
+
+@OptIn(ExperimentalNativeApi::class)
+actual fun useDefaultNThreads(): Int {
+    return Platform.getAvailableProcessors() / 2
 }
 
+private const val debug = false
+
 // TODO
 actual class Deque<T> actual constructor(initialCapacity: Int) {
-    private val delegate = ArrayDeque<ArraySection<*>>(initialCapacity) // could be a queue ? or a stack with a limit
+    private val delegate = ArrayDeque<T>(initialCapacity) // could be a queue ? or a stack with a limit
     private val mutex = Mutex()
+    private var complete = false
 
-    actual fun add(item: T) = runBlocking {
-        mutex.withLock {
-            delegate.add(item)
+    actual fun add(item: T) {
+        if (debug) println("Deque add")
+        runBlocking {
+            mutex.withLock {
+                if (debug) println(" Deque add lock")
+                delegate.add(item)
+            }
+            if (debug) println(" Deque add lock done")
         }
+        if (debug) println(" Deque add done")
     }
 
-    actual fun next(): T? = runBlocking {
-        mutex.withLock {
-            return deque.removeFirstOrNull()
+    actual fun next(): T? {
+        if (debug) println("Deque next")
+
+        var countWaits = 0
+        while (countWaits < 1000) {
+            var firstElement: T? = null
+            runBlocking {
+                if (debug) println(" Deque next withlock")
+                mutex.withLock {
+                    firstElement = delegate.removeFirstOrNull()
+                }
+            }
+            if (firstElement != null) {
+                if (debug)  println(" Deque got firstElement")
+                return firstElement
+            } else if (complete) {
+                if (debug) println(" Deque complete")
+                return null
+            } else {
+                if (debug) println(" Deque blocking")
+                runBlocking {
+                    delay(10)
+                }
+                countWaits++
+                if (debug) println(" Deque countWaits $countWaits")
+            }
         }
-        return delegate.poll() // can i block until available ??
+        throw RuntimeException("Deque next timed out (10 sec)")
+    }
+
+    actual fun complete() {
+        println(" complete called")
+        complete = true
     }
 }
\ No newline at end of file
diff --git a/core/src/nativeMain/kotlin/com/sunya/netchdfc/NetchdfCApi.kt b/core/src/nativeMain/kotlin/com/sunya/netchdfc/NetchdfCApi.kt
index aaf3d759..b97bc80c 100644
--- a/core/src/nativeMain/kotlin/com/sunya/netchdfc/NetchdfCApi.kt
+++ b/core/src/nativeMain/kotlin/com/sunya/netchdfc/NetchdfCApi.kt
@@ -3,18 +3,20 @@
 package com.sunya.netchdfc
 
 import com.sunya.cdm.api.*
+import com.sunya.cdm.array.ArrayFloat
 import com.sunya.cdm.array.ArrayInt
 import com.sunya.netchdf.openNetchdfFile
 
 import kotlinx.cinterop.CPointer
 import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.FloatVar
 import kotlinx.cinterop.IntVar
 import kotlinx.cinterop.LongVar
 import kotlinx.cinterop.addressOf
 import kotlinx.cinterop.pin
 
 fun version() : String {
-    return "netchdf version 0.4.0"
+    return "netchdf version 0.7.0"
 }
 
 fun openNetchdfFile(filename : String) : Netchdf? {
@@ -30,15 +32,30 @@ class VariableC(val varName: String, varShape: LongArray, val rank: Int) {
     val pinnedShape: CPointer<LongVar> = varShape.pin().addressOf(0)
 }
 
-fun Netchdf.readVariable(variableFullName : String) : VariableData {
+fun Netchdf.readVariableInt(variableFullName : String) : VariableDataInt {
     val vc = this.findVariable(variableFullName)!!
     val arrayInt = this.readArrayData(vc) as ArrayInt
-    return VariableData(vc.name, vc.shape.toIntArray(), arrayInt.nelems, arrayInt.values)
+    return VariableDataInt(vc.name, vc.shape.toIntArray(), arrayInt.nelems, arrayInt.values)
 }
 
-class VariableData(val varName: String, dataShape: IntArray, val nelems: Int, data: IntArray) {
+fun Netchdf.readVariableFloat(variableFullName : String) : VariableDataFloat {
+    val vc = this.findVariable(variableFullName)!!
+    val arrayFloat = this.readArrayData(vc) as ArrayFloat
+    return VariableDataFloat(vc.name, vc.shape.toIntArray(), arrayFloat.nelems, arrayFloat.values)
+}
+
+class VariableDataInt(val varName: String, dataShape: IntArray, val nelems: Int, data: IntArray) {
     val pinnedShape: CPointer<IntVar> = dataShape.pin().addressOf(0)
     val pinnedData: CPointer<IntVar> = data.pin().addressOf(0)
 }
 
+class VariableDataFloat(val varName: String, dataShape: IntArray, val nelems: Int, data: FloatArray) {
+    val pinnedShape: CPointer<IntVar> = dataShape.pin().addressOf(0)
+    val pinnedData: CPointer<FloatVar> = data.pin().addressOf(0)
+
+    init {
+        println("VariableDataFloat $varName nelems $nelems data size = ${data.size}")
+    }
+}
+
 
diff --git a/core/src/nativeTest/c/main.c b/core/src/nativeTest/c/main.c
index b3f331ff..5df2d12a 100644
--- a/core/src/nativeTest/c/main.c
+++ b/core/src/nativeTest/c/main.c
@@ -1,5 +1,20 @@
 #include "libnetchdf_api.h"
 #include "stdio.h"
+#include "math.h"
+#include <sys/time.h>
+
+void showDuration(char *what, struct timespec *start_time, struct timespec *end_time) {
+    long seconds = end_time->tv_sec - start_time->tv_sec;
+    long nanoseconds = end_time->tv_nsec - start_time->tv_nsec;
+
+    if (nanoseconds < 0) {
+        seconds--;
+        nanoseconds += 1000000000; // Add 1 billion nanoseconds (1 second)
+    }
+
+    long millis = nanoseconds/(1000 * 1000);
+    printf("%s took = %ld secs and %ld nanos \n", what, seconds, nanoseconds);
+}
 
 int main(int argc, char** argv) {
     // Obtain reference for calling Kotlin/Native functions
@@ -10,46 +25,77 @@ int main(int argc, char** argv) {
     lib->DisposeString(response);
 
     ////  libnetchdf_kref_com_sunya_cdm_api_Netchdf (*openNetchdfFileC)(const char* filename);
-    const char* filename = "simple_xy.nc";
+    const char* filename = "/home/stormy/dev/github/netcdf/netchdf/core/src/commonTest/data/netcdf4/tiling.nc4";
+    // const char* filename = "/home/all/testdata/cdmUnitTest/formats/netcdf4/espresso_his_20130913_0000_0007.nc";
     libnetchdf_kref_com_sunya_cdm_api_Netchdf netchdf = lib->kotlin.root.com.sunya.netchdfc.openNetchdfFile(filename);
 
     const char* cdl = lib->kotlin.root.com.sunya.cdm.api.cdl(netchdf);
+
     printf("file %s\n", filename);
     printf("%s\n", cdl);
     lib->DisposeString(cdl);
 
-    libnetchdf_kref_com_sunya_netchdfc_VariableC variableC = lib->kotlin.root.com.sunya.netchdfc.openVariable(netchdf, "data");
+    const char* varname = "Turbulence_SIGMET_AIRMET";
+    // const char* varname = "vbar"; //
+    libnetchdf_kref_com_sunya_netchdfc_VariableC variableC = lib->kotlin.root.com.sunya.netchdfc.openVariable(netchdf, varname);
     printf("get_varName=%s\n", lib->kotlin.root.com.sunya.netchdfc.VariableC.get_varName(variableC));
     int rank = lib->kotlin.root.com.sunya.netchdfc.VariableC.get_rank(variableC);
     printf("rank=%d\n", rank);
 
     void *vshape = lib->kotlin.root.com.sunya.netchdfc.VariableC.get_pinnedShape(variableC);
     long *shape = (long *) vshape;
+    printf("varshape\n");
     for (int idx=0; idx < rank; idx++) {
         printf(" %d == %ld\n", idx, *(shape+idx));
     }
     printf("\n");
 
-    libnetchdf_kref_com_sunya_netchdfc_VariableData variableData = lib->kotlin.root.com.sunya.netchdfc.readVariable(netchdf, "data");
-    printf("get_varName=%s\n", lib->kotlin.root.com.sunya.netchdfc.VariableData.get_varName(variableData));
-    int nelems = lib->kotlin.root.com.sunya.netchdfc.VariableData.get_nelems(variableData);
+    struct timeval timecheck;
+    gettimeofday(&timecheck, NULL);
+    long start = (long)timecheck.tv_sec * 1000 + (long)timecheck.tv_usec / 1000;
+
+    /*************** heres the meat */
+    libnetchdf_kref_com_sunya_netchdfc_VariableDataFloat variableData = lib->kotlin.root.com.sunya.netchdfc.readVariableFloat(netchdf, varname);
+
+    gettimeofday(&timecheck, NULL);
+    long end = (long)timecheck.tv_sec * 1000 + (long)timecheck.tv_usec / 1000;
+    printf("%ld milliseconds elapsed\n", (end - start));
+
+/*
+    printf("readVariable=%s\n", lib->kotlin.root.com.sunya.netchdfc.VariableDataFloat.get_varName(variableData));
+    int nelems = lib->kotlin.root.com.sunya.netchdfc.VariableDataFloat.get_nelems(variableData);
     printf("nelems=%d\n", nelems);
 
-    void *vdshape = lib->kotlin.root.com.sunya.netchdfc.VariableData.get_pinnedShape(variableData);
+    void *vdshape = lib->kotlin.root.com.sunya.netchdfc.VariableDataFloat.get_pinnedShape(variableData);
     int *dshape = (int *) vdshape;
     for (int idx=0; idx < rank; idx++) {
         printf(" %d == %d\n", idx, *(dshape+idx));
     }
-    printf("\n");
+    printf("\n"); */
 
-    void *vpdata = lib->kotlin.root.com.sunya.netchdfc.VariableData.get_pinnedData(variableData);
-    int *pdata = (int *) vpdata;
+    int nelems = lib->kotlin.root.com.sunya.netchdfc.VariableDataFloat.get_nelems(variableData);
+
+    void *vpdata = lib->kotlin.root.com.sunya.netchdfc.VariableDataFloat.get_pinnedData(variableData);
+    float *pdata = (float *) vpdata;
+    double sum = 0.0;
+    int count = 0;
     for (int idx=0; idx < nelems; idx++) {
-        printf(" %d == %d\n", idx, *(pdata+idx));
+        float value = *(pdata+idx);
+        // if (idx < 10) printf(" %d %g\n", idx, value);
+        // if (isfinite(value) == 0) printf(" %d %g\n", idx, value);
+        if (isfinite(value) != 0) sum += value;
+        // if (idx % 100000 == 0) printf("sum = %g\n", sum);
+        // if (idx % 100000 == 0) printf("sum = %g\n", sum);
+        count++;
     }
-    printf("\n");
+    end = (long)timecheck.tv_sec * 1000 + (long)timecheck.tv_usec / 1000;
+    printf("%ld milliseconds elapsed\n", (end - start));
+
+    printf("total = %g\n", sum);
+    printf("count elements = %d\n", count);
 
     return 0;
+}
 
 /*
     libnetchdf_kref_com_sunya_cdm_api_Variable variable = lib->kotlin.root.com.sunya.netchdfc.findVariable(netchdf, "data");
@@ -86,4 +132,3 @@ int main(int argc, char** argv) {
 
     return 0;
     */
-}
\ No newline at end of file
diff --git a/docs/Building.md b/docs/Building.md
index 336bfbda..5a44b39e 100644
--- a/docs/Building.md
+++ b/docs/Building.md
@@ -25,7 +25,7 @@ For example, choose one:
 
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/dev/core/build/bin/linuxX64/releaseShared
 
-sudo cp core/build/bin/linuxX64/releaseShared/libnetchdf.so /usr/local/lib
+sudo cp core/build/bin/linuxX64/debugShared/libnetchdf.so /usr/local/lib
 
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
 ````
@@ -33,7 +33,7 @@ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.
 ### create test c program
 
 ````
-cd core/ctest
+cd core/src/nativeTest/c
 gcc main.c \
   -I/home/stormy/dev/github/netcdf/netchdf/core/build/bin/linuxX64/debugShared \
   -L/home/stormy/dev/github/netcdf/netchdf/core/build/bin/linuxX64/debugShared \
@@ -51,7 +51,7 @@ gcc main.c \
 ~:$ echo $LD_LIBRARY_PATH
 /usr/local/lib:/home/stormy/install/HDF_Group/HDF5/1.14.6/lib:.
 
-cd core/ctest
+cd core/src/nativeTest/c
 cp /home/stormy/dev/github/netcdf/netchdf/core/build/bin/linuxX64/debugShared/libnetchdf.so .
 
 ./a.out \
@@ -60,7 +60,6 @@ cp /home/stormy/dev/github/netcdf/netchdf/core/build/bin/linuxX64/debugShared/li
 
 output is currently:
 
-netchdf version 0.4.0
 file simple_xy.nc
 netcdf3 simple_xy.nc {
   dimensions:
@@ -69,21 +68,29 @@ netcdf3 simple_xy.nc {
   variables:
     int data(x, y) ;
 }
+get_varName=data
+rank=2
+ 0 == 6
+ 1 == 12
+
+get_varName=data
 nelems=72
-first shape=-111406072
-second shape=32190
- 0 == -114171240
- 1 == 32190
- 2 == 1
- 3 == 0
- 4 == -1032136048
- 5 == 22331
- 6 == 124209
- 7 == 0
- 8 == 0
- 9 == 0
+ 0 == 6
+ 1 == 12
+
+ 0 == 0
+ 1 == 1
+ 2 == 2
+ 3 == 3
+ 4 == 4
+ 5 == 5
+ 6 == 6
+ 7 == 7
+  ...
+
+Hints:
+* if you keep core dumping before anything else, make sure your have copied the latest and correct library to /usr/local/lib
 
-````
 ### Example2
 
 ````
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 751db862..f36b40d8 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,5 +1,5 @@
 [versions]
-netchdf = "0.6.0"
+netchdf = "0.7.0"
 
 # main dependency versions
 kotlin = "2.1.21"
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index ca025c83..d4081da4 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/settings.gradle.kts b/settings.gradle.kts
index dbc088a0..ee2dcd1b 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -19,8 +19,7 @@ plugins {
 
 rootProject.name = "netchdf"
 
-// include("testFiles")
 include("core")
-include("cli")
+// include("cli")
 include("testclibs")
 include("testfiles")
diff --git a/testfiles/src/test/kotlin/com/sunya/netchdf/CountVersions.kt b/testfiles/src/test/kotlin/com/sunya/netchdf/CountVersions.kt
index 42ed6862..8dc50506 100644
--- a/testfiles/src/test/kotlin/com/sunya/netchdf/CountVersions.kt
+++ b/testfiles/src/test/kotlin/com/sunya/netchdf/CountVersions.kt
@@ -16,10 +16,10 @@ class CountVersions {
             return sequenceOf(
                 N3Files.Companion.files().asSequence(),
                 N4Files.Companion.files().asSequence(),
-                H5Files.Companion.files().asSequence(),
+                /* H5Files.Companion.files().asSequence(),
                 H4Files.Companion.files().asSequence(),
                 NetchdfExtraFiles.Companion.files(false).asSequence(),
-                JhdfFiles.Companion.files().asSequence(),
+                JhdfFiles.Companion.files().asSequence(), */
             )
                 .flatten()
                 .iterator()
@@ -122,7 +122,7 @@ class CountVersions {
 
                         ncfile.rootGroup().allVariables().forEach { v ->
                             val layout = hdf5File?.layoutName(v) ?: ""
-                            varSizes["$filename#${v.name}#$layout#${ncfile.size/(1000*1000)}"] = v.nelems
+                            varSizes["$filename#${v.name}#${v.datatype}#$layout#${ncfile.size/(1000*1000)}"] = v.nelems
                         }
                     }
                 }
diff --git a/testfiles/src/test/kotlin/com/sunya/netchdf/NetchdfTest.kt b/testfiles/src/test/kotlin/com/sunya/netchdf/NetchdfTest.kt
index ba15bca5..d652ba91 100644
--- a/testfiles/src/test/kotlin/com/sunya/netchdf/NetchdfTest.kt
+++ b/testfiles/src/test/kotlin/com/sunya/netchdf/NetchdfTest.kt
@@ -81,20 +81,30 @@ class NetchdfTest {
         readNetchdfData(testData + "devcdm/netcdf3/simple_xy.nc", showData = true)
     }
 
-    // this is working
     @Test
     fun readBtreeVer1() {
         readNetchdfData(testData + "/cdmUnitTest/formats/hdf5/OMI-Aura_L2-OMTO3_2009m0829t1219-o27250_v003-2009m0829t175727-2.he5",
             "/HDFEOS/SWATHS/OMI_Column_Amount_O3/Data_Fields/fc", showCdl = false, showData = false)
     }
 
-    // this is working
     @Test
     fun readBtreeVer1complex() {
         readNetchdfData(testData + "/cdmUnitTest/formats/hdf5/OMI-Aura_L2-OMTO3_2009m0829t1219-o27250_v003-2009m0829t175727-2.he5",
             "/HDFEOS/SWATHS/OMI_Column_Amount_O3/Data_Fields/fc", showCdl = false, showData = true)
     }
 
+    @Test
+    fun readNativeProblem() {
+        readNetchdfData("/home/all/testdata/cdmUnitTest/formats/netcdf4/espresso_his_20130913_0000_0007.nc",
+            "vbar", showCdl = false, sumData = true)
+    }
+
+    @Test
+    fun readNativeProblem2() {
+        readNetchdfData("/home/stormy/dev/github/netcdf/netchdf/core/src/commonTest/data/netcdf4/tiling.nc4",
+            "Turbulence_SIGMET_AIRMET", showCdl = false, sumData = true)
+    }
+
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 
     // fails on hdf5 /home/all/testdata/devcdm/netcdf4/vlenInt.nc
diff --git a/testfiles/src/test/kotlin/com/sunya/netchdf/hdf5/H5readConcurrentTest.kt b/testfiles/src/test/kotlin/com/sunya/netchdf/hdf5/H5readConcurrentTest.kt
index 9c93a95e..d4b3af98 100644
--- a/testfiles/src/test/kotlin/com/sunya/netchdf/hdf5/H5readConcurrentTest.kt
+++ b/testfiles/src/test/kotlin/com/sunya/netchdf/hdf5/H5readConcurrentTest.kt
@@ -2,13 +2,23 @@
 
 package com.sunya.netchdf.hdf5
 
+import com.sunya.cdm.api.Netchdf
+import com.sunya.cdm.api.Variable
+import com.sunya.netchdf.openNetchdfFile
 import com.sunya.netchdf.testfiles.H5Files
+import com.sunya.netchdf.testutils.AtomicDouble
+import com.sunya.netchdf.testutils.Stats
 import com.sunya.netchdf.testutils.compareChunkReading
+import com.sunya.netchdf.testutils.compareChunkReadingForVar
+import com.sunya.netchdf.testutils.sumValues
 import com.sunya.netchdf.testutils.testData
+import kotlin.collections.iterator
+import kotlin.concurrent.atomics.AtomicInt
 import kotlin.concurrent.atomics.ExperimentalAtomicApi
 import kotlin.system.measureNanoTime
 
 import kotlin.test.*
+import kotlin.use
 
 // Sanity check read Hdf5File header, for non-netcdf4 files
 class H5readConcurrentTest {
@@ -22,7 +32,7 @@ class H5readConcurrentTest {
 
     @Test
     fun sanity() {
-        compareChunkReading(testData + "cdmUnitTest/formats/netcdf4/hiig_forec_20140208.nc", "salt")
+        readChunksConcurrent("/home/stormy/dev/github/netcdf/netchdf/core/src/commonTest/data/netcdf4/tiling.nc4", "Turbulence_SIGMET_AIRMET")
     }
 
      // array reading is failing, btree address == -1
@@ -47,12 +57,14 @@ class H5readConcurrentTest {
         }
     }
 
+
+
     @Test
     fun timeH5compareReading() {
-        // val filename = "../core/src/commonTest/data/netcdf4/tiling.nc4"
-        val filename = "/home/all/testdata/cdmUnitTest/formats/netcdf4/hiig_forec_20140208.nc"
-        // val varname = "Turbulence_SIGMET_AIRMET" // "salt"
-        val varname = "salt"
+        val filename = "../core/src/commonTest/data/netcdf4/tiling.nc4" // /home/stormy/dev/github/netcdf/netchdf/core/src/commonTest/data/netcdf4/tiling.nc4
+        //val filename = "/home/all/testdata/cdmUnitTest/formats/netcdf4/hiig_forec_20140208.nc"
+        val varname = "Turbulence_SIGMET_AIRMET" // "salt"
+        //val varname = "salt"
         Hdf5File(filename).use { myfile : Hdf5File ->
             println("${myfile.type()} $filename ${myfile.size / 1000.0 / 1000.0} Mbytes")
 
@@ -66,7 +78,8 @@ class H5readConcurrentTest {
             for (nthreads in listOf(1, 2, 4, 8, 10, 16, 20, 24, 32, 40, 48)) {
                 myfile.useNThreads = nthreads
                 val time = measureNanoTime {
-                    myfile.readArrayData(myvar) // , null, recurse = true, countChunks = (nthreads == 1))
+                    val data = myfile.readArrayData(myvar)
+                    println(" sum= ${sumValues(data)}")// , null, recurse = true, countChunks = (nthreads == 1))
                 }
                 println("$nthreads, ${time * nano}")
                 val map1 = timing.getOrPut(nthreads) { mutableMapOf() }
@@ -78,7 +91,12 @@ class H5readConcurrentTest {
             for (nthreads in listOf(1, 2, 4, 8, 10, 16, 20, 24, 32, 40, 48)) {
                 myfile.useNThreads = nthreads
                 val time = measureNanoTime {
-                    myfile.chunkIterator(myvar)
+                    var sum = 0.0
+                    val iter = myfile.chunkIterator(myvar)
+                    iter.forEach { chunk ->
+                        sum += sumValues(chunk.array)
+                    }
+                    println(" sum= $sum")
                 }
                 println("$nthreads, ${time * nano}")
                 val map1 = timing.getOrPut(nthreads) { mutableMapOf() }
@@ -90,8 +108,14 @@ class H5readConcurrentTest {
             for (nthreads in listOf(1, 2, 4, 8, 10, 16, 20, 24, 32, 40, 48)) {
                 myfile.useNThreads = nthreads
                 val time = measureNanoTime {
+                    val suma = AtomicDouble(0.0)
                     //     fun <T> readChunksConcurrent(v2: Variable<T>, lamda : (ArraySection<*>) -> Unit, done : () -> Unit,  nthreads: Int?) {
-                    myfile.readChunksConcurrent(myvar, lamda = { }, { }, wantSection = null, nthreads)
+                    myfile.readChunksConcurrent(myvar, lamda = {
+                        val sum = sumValues(it.array)
+                        suma.getAndAdd(sum)
+                    }, { }, wantSection = null, nthreads)
+
+                    println(" sum= ${suma.get()}")
                 }
                 println("$nthreads, ${time * nano}")
                 val map1 = timing.getOrPut(nthreads) { mutableMapOf() }
@@ -99,7 +123,8 @@ class H5readConcurrentTest {
             }
 
             val table = buildString {
-                    appendLine("Read chunked data")
+                    appendLine("Xeon E5-2680 24 CPUs 48 threads, Samsung PM991 SSD")
+                    appendLine("67M floats, 81 chunks, with deflate")
                     appendLine("nthreads,  time in secs")
                     val categories = timing[1]!!.keys
                     append("      ,")
@@ -121,4 +146,38 @@ class H5readConcurrentTest {
     }
 }
 
-val nano = 1.0e-9
\ No newline at end of file
+val nano = 1.0e-9
+
+fun readChunksConcurrent(filename: String, varname : String) {
+    openNetchdfFile(filename).use { myfile ->
+        if (myfile == null) {
+            println("*** not a netchdf file = $filename")
+            return
+        }
+        println("${myfile.type()} $filename ${myfile.size / 1000.0 / 1000.0} Mbytes")
+        val myvar = myfile.rootGroup().allVariables().find { it.fullname() == varname } ?: throw RuntimeException("cant find $varname")
+        println(myvar.nameAndShape())
+        readChunksConcurrent(myfile, myvar)
+    }
+}
+
+fun readChunksConcurrent(myfile: Netchdf, myvar: Variable<*>) {
+    assertTrue(myfile is Hdf5File)
+    val hdf5 = myfile
+
+    val counta = AtomicInt(0)
+    val suma = AtomicDouble(0.0)
+    val layout = hdf5.layoutName(myvar)
+    if (layout == "DataLayoutBTreeVer1") {
+        val time2 = measureNanoTime {
+            hdf5.readChunksConcurrent(myvar, { it ->
+                val sum = sumValues(it.array)
+                suma.getAndAdd(sum)
+                counta.fetchAndAdd(1)
+            }, done = { })
+        }
+        val countConcurrentRead = counta.load()
+        val sumConcurrentRead = suma.get()
+        println("  nelems = $countConcurrentRead sum = $sumConcurrentRead")
+    }
+}
\ No newline at end of file
diff --git a/testfiles/src/test/kotlin/com/sunya/netchdf/testutils/CompareChunkReading.kt b/testfiles/src/test/kotlin/com/sunya/netchdf/testutils/CompareChunkReading.kt
index ce76dcb5..554bda72 100644
--- a/testfiles/src/test/kotlin/com/sunya/netchdf/testutils/CompareChunkReading.kt
+++ b/testfiles/src/test/kotlin/com/sunya/netchdf/testutils/CompareChunkReading.kt
@@ -79,10 +79,6 @@ fun compareChunkReadingForVar(myfile: Netchdf, myvar: Variable<*>, showStats: Bo
                     val sum = sumValues(it.array)
                     suma.getAndAdd(sum)
                     counta.fetchAndAdd(1)
-                    // println(" chunk ${it.section} sum $sum")
-                    /* if (it.section.toString().contains("[0:0][0:17][0:97][148:295]")) {
-                        println(it)
-                    } */
                 }, done = { })
             }
             val countConcurrentRead = counta.load()
@@ -100,36 +96,6 @@ fun compareChunkReadingForVar(myfile: Netchdf, myvar: Variable<*>, showStats: Bo
     return countChunkIterator
 }
 
-private fun sumValues(array : ArrayTyped<*>): Double {
-    var result = 0.0
-
-    if (array.datatype.isNumber) {
-        for (value in array) {
-            val number = (value as Number)
-            val numberd: Double = number.toDouble()
-            if (numberd.isFinite()) {
-                result += numberd
-            }
-        }
-    } else if (array.datatype.isIntegral) {
-        for (value in array) {
-            val useValue = when (value) {
-                is UByte -> value.toByte()
-                is UShort -> value.toShort()
-                is UInt -> value.toInt()
-                is ULong -> value.toLong()
-                else -> value
-            }
-            val number = (useValue as Number)
-            val numberd: Double = number.toDouble()
-            if (numberd.isFinite()) {
-                result += numberd
-            }
-        }
-    }
-    return result
-}
-
 //////////////////////////////////////////////////////////////////////////////////////
 // compare reading data chunkIterate API with Netch and NC
 
diff --git a/testfiles/src/test/kotlin/com/sunya/netchdf/testutils/ReadCommon.kt b/testfiles/src/test/kotlin/com/sunya/netchdf/testutils/ReadCommon.kt
index a1a33200..f6c73de5 100644
--- a/testfiles/src/test/kotlin/com/sunya/netchdf/testutils/ReadCommon.kt
+++ b/testfiles/src/test/kotlin/com/sunya/netchdf/testutils/ReadCommon.kt
@@ -20,7 +20,8 @@ fun showNetchdfHeader(filename: String) {
     }
 }
 
-fun readNetchdfData(filename: String, varname: String? = null, section: SectionPartial? = null, showCdl : Boolean = false, showData : Boolean = false) {
+fun readNetchdfData(filename: String, varname: String? = null, section: SectionPartial? = null,
+                    showCdl : Boolean = false, showData : Boolean = false, sumData : Boolean = false) {
     // println("=============================================================")
     openNetchdfFile(filename).use { myfile ->
         if (myfile == null) {
@@ -28,14 +29,15 @@ fun readNetchdfData(filename: String, varname: String? = null, section: SectionP
             return
         }
         println("--- ${myfile.type()} $filename ")
-        readMyData(myfile,varname, section, showCdl, showData)
+        readMyData(myfile,varname, section, showCdl, showData, sumData)
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 // just read data from myfile
 
-fun readMyData(myfile: Netchdf, varname: String? = null, section: SectionPartial? = null, showCdl : Boolean = false, showData : Boolean = false) {
+fun readMyData(myfile: Netchdf, varname: String? = null, section: SectionPartial? = null,
+               showCdl : Boolean = false, showData : Boolean = false, sumData : Boolean = false) {
 
     if (showCdl) {
         println(myfile.cdl())
@@ -47,25 +49,26 @@ fun readMyData(myfile: Netchdf, varname: String? = null, section: SectionPartial
             println("cant find $varname")
             return
         }
-        readOneVar(myvar, myfile, section, showData)
+        readOneVar(myvar, myfile, section, showData, sumData)
     } else {
         myfile.rootGroup().allVariables().forEach { it ->
-            readOneVar(it, myfile, null, showData)
+            readOneVar(it, myfile, null, showData, sumData)
         }
     }
 }
 
 const val maxBytes = 10_000_000
 
-fun readOneVar(myvar: Variable<*>, myfile: Netchdf, section: SectionPartial?, showData : Boolean = false) {
+fun readOneVar(myvar: Variable<*>, myfile: Netchdf, section: SectionPartial?,
+               showData : Boolean = false, sumData : Boolean = false) {
     println("   read ${myvar.name}")
 
     val sectionF = SectionPartial.fill(section, myvar.shape)
     val nbytes = sectionF.totalElements * myvar.datatype.size
     val myvarshape = myvar.shape.toIntArray()
 
-    if (nbytes > maxBytes) {
-        if (showData) println(" * ${myvar.fullname()} read too big: ${nbytes} > $maxBytes")
+    if (!sumData && nbytes > maxBytes) {
+        println(" * ${myvar.fullname()} read too big: ${nbytes} > $maxBytes")
     } else {
         val mydata = myfile.readArrayData(myvar, section)
         if (showData) println(" ${myvar.datatype} ${myvar.fullname()}${myvar.shape.contentToString()} = " +
@@ -76,6 +79,7 @@ fun readOneVar(myvar: Variable<*>, myfile: Netchdf, section: SectionPartial?, sh
             assertTrue(myvarshape.equivalent(mydata.shape), "variable ${myvar.name}")
         }
         if (showData) println(mydata)
+        if (sumData) println("sum = ${sumValues(mydata)}")
     }
 
     if (myvar.nelems > 8 && myvar.datatype != Datatype.CHAR) {
@@ -123,4 +127,34 @@ fun readMiddleSection(myfile: Netchdf, myvar: Variable<*>, shape: LongArray, sho
         assertTrue(middleShape.equivalent(mydata.shape), "variable ${myvar.name}")
     }
     if (showData) println(mydata)
+}
+
+fun sumValues(array : ArrayTyped<*>): Double {
+    var result = 0.0
+
+    if (array.datatype.isNumber) {
+        for (value in array) {
+            val number = (value as Number)
+            val numberd: Double = number.toDouble()
+            if (numberd.isFinite()) {
+                result += numberd
+            }
+        }
+    } else if (array.datatype.isIntegral) {
+        for (value in array) {
+            val useValue = when (value) {
+                is UByte -> value.toByte()
+                is UShort -> value.toShort()
+                is UInt -> value.toInt()
+                is ULong -> value.toLong()
+                else -> value
+            }
+            val number = (useValue as Number)
+            val numberd: Double = number.toDouble()
+            if (numberd.isFinite()) {
+                result += numberd
+            }
+        }
+    }
+    return result
 }
\ No newline at end of file